avorelo 0.1.0

package/scripts/cco-status.js

@@ -0,0 +1,430 @@
+"use strict";
+
+const { buildStatusDashboard } = require("./lib/dashboard");
+const { buildValueSummary } = require("./lib/status-value-summary");
+const { buildPlanSurface } = require("./lib/plan-surface");
+const {
+  buildCompactProMomentLines,
+  buildProMomentSurface,
+  recordProMomentEvaluation,
+} = require("./lib/pro-moments");
+
+function optionalRequire(modulePath, fallback) {
+  try {
+    return require(modulePath);
+  } catch {
+    return fallback;
+  }
+}
+
+const { formatReentryMemoryText } = optionalRequire("./lib/reentry-memory-status", {
+  formatReentryMemoryText: () => null,
+});
+const { formatBudgetStatusText } = optionalRequire("./lib/context-budget-guard", {
+  formatBudgetStatusText: () => null,
+});
+const { formatWorkflowDisciplineText } = optionalRequire("./lib/workflow-discipline", {
+  formatWorkflowDisciplineText: () => null,
+});
+const { ValueLedger, buildValueLedgerSummary, formatValueLedgerLine } = optionalRequire("./lib/value-ledger", {
+  ValueLedger: class {
+    loadAll() {
+      return [];
+    }
+  },
+  buildValueLedgerSummary: () => null,
+  formatValueLedgerLine: () => null,
+});
+const { buildContextSafetyStatus } = optionalRequire("./lib/context-safety", {
+  buildContextSafetyStatus: () => ({ showInStatus: false, statusLine: null }),
+});
+const { formatRunImprovementsText } = optionalRequire("./lib/run-improvements", {
+  formatRunImprovementsText: () => null,
+});
+const { formatLearningSummaryStatusLine } = optionalRequire("./lib/learning-memory", {
+  formatLearningSummaryStatusLine: () => null,
+});
+
+function loadLastScore(cwd) {
+  try {
+    const p = require("path").join(cwd, ".claude", "cco", "state", "last-score.json");
+    if (!require("fs").existsSync(p)) return null;
+    const raw = require("fs").readFileSync(p, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function formatLastScoreLine(score) {
+  if (!score || !score.status || score.status === "NO DATA") return null;
+  const runPart = score.runId ? ` (run: ${score.runId})` : "";
+  return `Last score: ${score.status}${runPart} — ${score.reason}`;
+}
+const { buildActivationSummary, formatActivationStatusLine } = optionalRequire("./lib/activation/activation-summary", {
+  buildActivationSummary: () => null,
+  formatActivationStatusLine: () => "Activation: local status surface unavailable",
+});
+const { readWorkspaceMap } = optionalRequire("./lib/workspace-map", {
+  readWorkspaceMap: () => null,
+});
+const { buildSessionContextSurface } = optionalRequire("./lib/session-context-optimizer", {
+  buildSessionContextSurface: () => null,
+});
+const { summarizeLatestLearningSignals } = optionalRequire("./lib/product-learning-events", {
+  summarizeLatestLearningSignals: () => null,
+});
+
+function formatCurrentStateLines(status) {
+  const currentState = status.currentState || null;
+  if (!currentState) {
+    return [
+      "Current state:",
+      "- No current-state surface is available.",
+    ];
+  }
+
+  const lines = ["Current state:"];
+  const truthSource = currentState.truthSource || "none";
+  lines.push(`- Truth source: ${truthSource}`);
+
+  if (currentState.whereAmINow) {
+    lines.push(`- Where am I now: ${currentState.whereAmINow}`);
+  }
+  if (currentState.whatCanIHonestlyClaim) {
+    lines.push(`- What can I honestly claim: ${currentState.whatCanIHonestlyClaim}`);
+  }
+  if (currentState.nextBoundedAction) {
+    lines.push(`- What should I do next: ${currentState.nextBoundedAction}`);
+  }
+  if (currentState.reentryStatus) {
+    lines.push(`- Re-entry: ${currentState.reentryStatus}`);
+  }
+  if (currentState.latestTrustworthyRunId) {
+    lines.push(`- Trustworthy run: ${currentState.latestTrustworthyRunId}`);
+  }
+  if (currentState.readinessState) {
+    lines.push(`- Readiness: ${currentState.readinessState}`);
+  }
+  if (currentState.rollbackAvailable === true) {
+    lines.push("- Rollback: available");
+  }
+  if (Array.isArray(currentState.limitations)) {
+    currentState.limitations.filter(Boolean).forEach((item) => lines.push(`- Note: ${item}`));
+  }
+  return lines;
+}
+
+function resolveStatus(input) {
+  if (typeof input === "string") {
+    return buildStatusDashboard(input, { limit: 7 });
+  }
+  if (input && typeof input === "object") {
+    return input;
+  }
+  return buildStatusDashboard(process.env.PROJECT_CWD || process.cwd(), { limit: 7 });
+}
+
+function workspaceMapLine(cwd) {
+  const map = readWorkspaceMap(cwd);
+  if (!map) return null;
+  return `Workspace Map: ${map.status} · ${map.capabilitiesMapped} capabilities · ${map.topGaps[0] || "no major gaps"}`;
+}
+
+function learningLine(cwd) {
+  const summary = summarizeLatestLearningSignals(cwd);
+  if (!summary || !summary.totalEvents) return null;
+  const top = summary.topEvents[0];
+  return `Product learning: ${summary.totalEvents} local events${top ? ` · top=${top.eventName}` : ""}`;
+}
+
+function formatBoundedStatus(statusInput) {
+  const status = resolveStatus(statusInput);
+  const cwd = typeof statusInput === "string"
+    ? statusInput
+    : (status?.cwd || process.env.PROJECT_CWD || process.cwd());
+  const planSurface = buildPlanSurface(cwd);
+  const proMoment = status?.proMoment || buildProMomentSurface(cwd, {
+    surface: "status",
+    status,
+  });
+  const fixes = (status.topRecommendedFixes || []).slice(0, 3);
+  const summary = buildValueSummary(status);
+  const agentSecurityLine = status.agentSecurity?.showInStatus ? [status.agentSecurity.statusLine] : [];
+  const governanceLine = status.agentAccessGovernance?.showInStatus ? [status.agentAccessGovernance.statusLine] : [];
+  const safePathLine = status.safePath?.showInStatus ? [status.safePath.statusLine] : [];
+  const intakeLine = status.installIntakeRisk?.showInStatus ? [status.installIntakeRisk.statusLine] : [];
+  const skillsLine = status.skillsOperatingLayer?.showInStatus ? [status.skillsOperatingLayer.statusLine] : [];
+  const browserCapabilityLine = status.browserCapability?.showInStatus ? [status.browserCapability.statusLine] : [];
+  const orchestrationLine = status.orchestration?.showInStatus ? [status.orchestration.statusLine] : [];
+  const agentModelOrchestrationLine = status.agentModelOrchestration?.status && status.agentModelOrchestration.status !== "not_run" && status.agentModelOrchestration.status !== "error"
+    ? [`Agent orchestration: FOUNDATION · workers=${status.agentModelOrchestration.stageCount || 0} stages · local=${status.agentModelOrchestration.localWorkersAvailable || 0} · limited=${status.agentModelOrchestration.limitedWorkers || 0} · next=${status.agentModelOrchestration.nextAction || "run avorelo route"}`]
+    : [];
+  const planSecurityLines = planSurface.security
+    ? [
+        `Plan security: ${planSurface.security.headlineLine}.`,
+        planSurface.security.postureLine,
+        planSurface.security.latestEvidence?.summary ? `Latest security evidence: ${planSurface.security.latestEvidence.summary}` : null,
+      ].filter(Boolean)
+    : [];
+  const visualQaLine = planSurface.visualQa?.quota?.tracked
+    ? [`Visual QA: ${planSurface.visualQa.quota.used}/${planSurface.visualQa.quota.limit} ${planSurface.visualQa.quota.period} used${planSurface.visualQa.runner.available ? "" : " · runner unavailable"}`]
+    : [];
+  const memoryText = formatReentryMemoryText(status.reentryMemory);
+  const memoryLines = memoryText ? [memoryText] : [];
+  const budgetText = formatBudgetStatusText(status.contextBudgetGuard);
+  const plan = status.contextBudgetGuard?.reductionPlan;
+  const planLines = plan
+    ? [
+        `Context budget: ${plan.estimatedTotalTokens} tokens estimated / ${plan.recommendedLimitTokens} limit${plan.overBudget ? " [OVER BUDGET]" : ""}`,
+        plan.topHotspot ? `  Top hotspot: ${plan.topHotspot.path} (${plan.topHotspot.estimatedTokens} tokens)` : null,
+        `  Action: ${plan.nextBestAction}`,
+      ].filter(Boolean)
+    : [];
+  const budgetLines = planLines.length > 0 ? planLines : (budgetText ? [budgetText] : []);
+  const workflowText = formatWorkflowDisciplineText(status.workflowDiscipline);
+  const workflowLines = workflowText ? [workflowText] : [];
+  const sessionContextLines = (() => {
+    try {
+      const sc = buildSessionContextSurface(cwd);
+      return sc?.showInStatus && sc.statusLine ? [sc.statusLine] : [];
+    } catch { return []; }
+  })();
+  const workspaceMapLines = (() => {
+    const line = workspaceMapLine(cwd);
+    return line ? [line] : [];
+  })();
+  const learningLines = (() => {
+    const line = learningLine(cwd);
+    return line ? [line] : [];
+  })();
+  const lastScoreLines = (() => {
+    try {
+      const s = loadLastScore(cwd);
+      const line = formatLastScoreLine(s);
+      return line ? [line] : [];
+    } catch { return []; }
+  })();
+  const ledgerLine = (() => {
+    try {
+      const ledger = new ValueLedger(cwd);
+      const events = ledger.loadAll();
+      const ledgerSummary = buildValueLedgerSummary(events);
+      const line = formatValueLedgerLine(ledgerSummary);
+      return line ? [line] : [];
+    } catch { return []; }
+  })();
+  const runImprovementsLines = (() => {
+    try {
+      const text = formatRunImprovementsText(cwd);
+      return text ? [text] : [];
+    } catch { return []; }
+  })();
+  const learningSummaryLines = (() => {
+    try {
+      const line = formatLearningSummaryStatusLine(cwd);
+      return line ? [line] : [];
+    } catch { return []; }
+  })();
+  const contextSafetyLines = (() => {
+    try {
+      const s = buildContextSafetyStatus(cwd);
+      return s.showInStatus && s.statusLine ? [s.statusLine] : [];
+    } catch { return []; }
+  })();
+  const operatingValueLine = (() => {
+    try {
+      const { buildOperatingValueSurface } = require("./lib/operating-value");
+      const ov = buildOperatingValueSurface(cwd);
+      if (!ov || ov.status !== "available" || !ov.shouldShowInSession) return [];
+      const readiness = ov.readinessBand ? ` · readiness: ${ov.readinessBand}` : "";
+      return [`Operating value: ${ov.hero || "surfaces available"}${readiness}`];
+    } catch { return []; }
+    })();
+  const proMomentLines = buildCompactProMomentLines(proMoment);
+  return [
+    "Avorelo - Status",
+    `Plan: ${planSurface.planLabel}`,
+    ...(planSurface.overrideNote ? [planSurface.overrideNote] : []),
+    planSurface.includedLine,
+    `Focus: ${status.tier}`,
+    `Profile: ${status.profile || "balanced"}`,
+    formatActivationStatusLine(status.activation || buildActivationSummary(cwd)),
+    ...formatCurrentStateLines(status),
+    ...agentSecurityLine,
+    ...governanceLine,
+    ...safePathLine,
+    ...intakeLine,
+    ...skillsLine,
+    ...browserCapabilityLine,
+    ...orchestrationLine,
+    ...agentModelOrchestrationLine,
+    ...visualQaLine,
+    ...planSecurityLines,
+    ...contextSafetyLines,
+    "Top fixes:",
+    ...fixes.map((f, i) => `${i + 1}. ${f.text}`),
+    `Optimization next: ${status.nextBestAction || "No action pending"}`,
+    `Improvements: ~${status.benefitSummary?.minutesSavedEstimate || 0} min`,
+    `Summary: ${summary}`,
+    ...memoryLines,
+    ...budgetLines,
+    ...workflowLines,
+    ...sessionContextLines,
+    ...operatingValueLine,
+    ...proMomentLines,
+    ...workspaceMapLines,
+    ...learningLines,
+    ...lastScoreLines,
+    ...ledgerLine,
+    ...runImprovementsLines,
+    ...learningSummaryLines,
+  ].join("\n");
+}
+
+function buildStatusJson(statusInput) {
+  const status = resolveStatus(statusInput);
+  const cwd = typeof statusInput === "string"
+    ? statusInput
+    : (status?.cwd || process.env.PROJECT_CWD || process.cwd());
+  const planSurface = buildPlanSurface(cwd);
+  let valueLedger = null;
+  let contextSafety = null;
+  try {
+    const ledger = new ValueLedger(cwd);
+    const events = ledger.loadAll();
+    valueLedger = buildValueLedgerSummary(events);
+  } catch {}
+  try {
+    contextSafety = buildContextSafetyStatus(cwd);
+  } catch {}
+  const activation = status.activation || buildActivationSummary(cwd);
+  const workspaceMap = readWorkspaceMap(cwd);
+  const productLearning = summarizeLatestLearningSignals(cwd);
+  const proMoment = status?.proMoment || buildProMomentSurface(cwd, {
+    surface: "status",
+    status,
+  });
+  let sessionContext = null;
+  try { sessionContext = buildSessionContextSurface(cwd); } catch {}
+  return {
+    statusDashboardVersion: status.statusDashboardVersion || 4,
+    cwd,
+    what: "Status snapshot generated.",
+    why: "Shows current bounded state first, then Time + Risk + Cost posture with deterministic top fixes.",
+    tier: status.tier,
+    profile: status.profile,
+    summaryFraming: status.teamRollup?.summaryFraming || "Time + Risk + Cost status summary.",
+    planSummary: planSurface,
+    securitySummary: planSurface.security || null,
+    nextBestAction: status.nextBestAction || "",
+    topRecommendedFixes: status.topRecommendedFixes || [],
+    topFixesNow: (status.topRecommendedFixes || []).slice(0, 3),
+    benefitSummary: status.benefitSummary || null,
+    weeklySummary: status.weeklySummary || null,
+    teamDefaultsApplied: status.teamDefaultsApplied || null,
+    teamRollup: status.teamRollup || null,
+    memorySummary: status.memorySummary || null,
+    contextBudgetPlan: status.contextBudgetPlan || null,
+    effectivenessScorecard: status.effectivenessScorecard || null,
+    settingsControls: status.settingsControls || null,
+    activation,
+    workspaceMap,
+    productLearning,
+    proMoment,
+    sessionContext,
+    valueLedger,
+    contextSafety,
+    ...(status.agentSecurity ? { agentSecurity: status.agentSecurity } : {}),
+    ...(status.agentAccessGovernance ? { agentAccessGovernance: status.agentAccessGovernance } : {}),
+    ...(status.safePath ? { safePath: status.safePath } : {}),
+    ...(status.installIntakeRisk ? { installIntakeRisk: status.installIntakeRisk } : {}),
+    ...(status.skillsOperatingLayer ? { skillsOperatingLayer: status.skillsOperatingLayer } : {}),
+    ...(status.browserCapability ? { browserCapability: status.browserCapability } : {}),
+    ...(status.orchestration ? { orchestration: status.orchestration } : {}),
+    ...(status.agentModelOrchestration ? { agentModelOrchestration: status.agentModelOrchestration } : {}),
+    ...(status.promptContextTokenOptimization ? { promptContextTokenOptimization: status.promptContextTokenOptimization } : {}),
+    seamlessOutcome: (() => {
+      try {
+        const { buildSeamlessOutcomeSurface } = require("./lib/seamless-outcome");
+        return buildSeamlessOutcomeSurface(cwd);
+      } catch { return null; }
+    })(),
+    seamlessRealityGate: (() => {
+      try {
+        const { buildRealityGateSurface } = require("./lib/seamless-reality-gate");
+        return buildRealityGateSurface(cwd);
+      } catch { return null; }
+    })(),
+    workAwareOrchestration: (() => {
+      try {
+        const { buildWorkOrchestrationSurface } = require("./lib/work-aware-orchestration");
+        return buildWorkOrchestrationSurface(cwd);
+      } catch { return null; }
+    })(),
+    workLedger: (() => {
+      try {
+        const { buildWorkLedgerSurface } = require("./lib/work-ledger");
+        return buildWorkLedgerSurface(cwd);
+      } catch { return null; }
+    })(),
+    companyLoop: (() => {
+      try {
+        const { buildCompanyLoopSurface } = require("./lib/company-loop");
+        return buildCompanyLoopSurface(cwd);
+      } catch { return null; }
+    })(),
+    currentState: status.currentState || {
+      truthSource: "none",
+      isCanonicalTruthAvailable: false,
+      whereAmINow: null,
+      whatCanIHonestlyClaim: null,
+      nextBoundedAction: null,
+      reentryStatus: null,
+      latestTrustworthyRunId: null,
+      rollbackAvailable: null,
+      readinessState: null,
+      stateSource: null,
+      artifactRefs: [],
+      limitations: [],
+    },
+    reentryMemory: status.reentryMemory || null,
+    contextBudgetGuard: status.contextBudgetGuard || null,
+    workflowDiscipline: status.workflowDiscipline || null,
+    runImprovements: (() => {
+      try {
+        const { loadRunImprovements } = require("./lib/run-improvements");
+        return loadRunImprovements(cwd);
+      } catch { return null; }
+    })(),
+  };
+}
+
+function parseArgs(argv) {
+  return {
+    text: argv.includes("--text"),
+    json: argv.includes("--json"),
+  };
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const cwd = process.env.PROJECT_CWD || process.cwd();
+  const response = buildStatusJson(cwd);
+  if (args.text && !args.json) {
+    process.stdout.write(`${formatBoundedStatus(response)}\n`);
+    recordProMomentEvaluation(cwd, response.proMoment, { humanVisible: true });
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(response, null, 2)}\n`);
+  recordProMomentEvaluation(cwd, response.proMoment, { humanVisible: false });
+}
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  formatBoundedStatus,
+  buildStatusJson,
+  parseArgs,
+};

package/scripts/lib/activation/account-state.js

@@ -0,0 +1,37 @@
+"use strict";
+
+const { safeReadJson } = require("../fsx");
+const { USER_STATE_FILE_REL } = require("./connect-account");
+
+const USER_STATE_REL = USER_STATE_FILE_REL;
+
+function defaultAccountState() {
+  return {
+    connected: false,
+    plan: "free",
+    localOnly: true,
+  };
+}
+
+function normalizePlan(plan) {
+  const normalized = String(plan || "").trim().toLowerCase();
+  if (normalized === "free" || normalized === "pro" || normalized === "team") return normalized;
+  return normalized ? "unknown" : "free";
+}
+
+function readAccountState(cwd) {
+  const data = safeReadJson(cwd, USER_STATE_REL, defaultAccountState());
+  const connected = data?.connected === true;
+  const localOnly = typeof data?.localOnly === "boolean" ? data.localOnly : connected !== true;
+  return {
+    connected,
+    plan: normalizePlan(data?.plan),
+    localOnly,
+  };
+}
+
+module.exports = {
+  USER_STATE_REL,
+  defaultAccountState,
+  readAccountState,
+};