avorelo 0.3.8 → 0.4.0-rc.2

package/scripts/cco-status.js

@@ -0,0 +1,540 @@
+"use strict";
+
+const { buildStatusDashboard } = require("./lib/dashboard");
+const { buildValueSummary } = require("./lib/status-value-summary");
+const { buildPlanSurface } = require("./lib/plan-surface");
+const { formatProductHomeStatusLine } = require("./lib/product-home-receipt");
+const { formatAgentActivationStatusLine } = require("./lib/agent-activation-readiness");
+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,
+});
+const { formatProofSavingsStatusLine, buildProofSavingsSurface } = optionalRequire(
+  "./lib/proof-savings-report",
+  {
+    formatProofSavingsStatusLine: () => null,
+    buildProofSavingsSurface: () => ({
+      showInStatus: false,
+      statusLine: null,
+      evidenceQuality: null,
+      estimatedSavings: null,
+      openRisks: 0,
+      nextBestAction: null,
+      validatedSignalCount: 0,
+      savingsConfidence: "insufficient",
+    }),
+  }
+);
+
+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 productHomeLine = status.productHome ? [formatProductHomeStatusLine(status.productHome)] : [];
+  const agentReadinessLine = status.agentReadiness ? [formatAgentActivationStatusLine(status.agentReadiness)] : [];
+  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 capabilityIntakeLine = status.capabilityIntake?.showInStatus ? [status.capabilityIntake.statusLine] : [];
+  const skillsLine = status.skillsOperatingLayer?.showInStatus ? [status.skillsOperatingLayer.statusLine] : [];
+  const governedActionExposureLine = status.governedActionExposure?.showInStatus ? [status.governedActionExposure.statusLine] : [];
+  const governedWorkspaceHygieneLine = status.governedWorkspaceHygiene?.showInStatus ? [status.governedWorkspaceHygiene.statusLine] : [];
+  const learningExperimentationLine = status.learningExperimentation?.showInStatus ? [status.learningExperimentation.statusLine] : [];
+  const browserCapabilityLine = status.browserCapability?.showInStatus ? [status.browserCapability.statusLine] : [];
+  const browserProofWorkflowLine = status.browserProofWorkflow?.showInStatus ? [status.browserProofWorkflow.statusLine] : [];
+  const safeRepairLine = status.safeRepair?.showInStatus ? [status.safeRepair.statusLine] : [];
+  const scopeRepairLine = status.scopeRepair?.showInStatus ? [status.scopeRepair.statusLine] : [];
+  const nextRunContinuityLine = status.nextRunContinuity?.showInStatus ? [status.nextRunContinuity.statusLine] : [];
+  const dataPermissionsLine = status.dataPermissions?.showInStatus ? [status.dataPermissions.statusLine] : [];
+  const deploymentEnvironmentLine = status.deploymentEnvironment?.showInStatus ? [status.deploymentEnvironment.statusLine] : [];
+  const aiEfficiencyRoutingLine = (() => {
+    try {
+      const { buildAiWorkEfficiencyRoutingSurface } = require("./lib/ai-work-efficiency-routing");
+      const s = buildAiWorkEfficiencyRoutingSurface(cwd, { buildIfMissing: false });
+      return s && s.showInStatus ? [s.statusLine] : [];
+    } catch { return []; }
+  })();
+  const supplyChainDependencyLine = status.supplyChainDependency?.showInStatus ? [status.supplyChainDependency.statusLine] : [];
+  const orchestrationLine = status.orchestration?.showInStatus ? [status.orchestration.statusLine] : [];
+  const outcomeEvidenceLine = status.outcomeEvidence?.showInStatus ? [status.outcomeEvidence.statusLine] : [];
+  const productionConfidenceLine = status.productionConfidence?.showInStatus ? [status.productionConfidence.statusLine] : [];
+  const valueSignalsLine = status.valueSignals?.showInStatus ? [status.valueSignals.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 proofSavingsLines = (() => {
+    try {
+      const line = formatProofSavingsStatusLine(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);
+  const allLines = [
+    "Avorelo - Status",
+    `Plan: ${planSurface.planLabel}`,
+    ...(planSurface.overrideNote ? [planSurface.overrideNote] : []),
+    planSurface.includedLine,
+    `Focus: ${status.tier}`,
+    `Profile: ${status.profile || "balanced"}`,
+    formatActivationStatusLine(status.activation || buildActivationSummary(cwd)),
+    ...agentReadinessLine,
+    ...productHomeLine,
+    ...formatCurrentStateLines(status),
+    ...agentSecurityLine,
+    ...governanceLine,
+    ...safePathLine,
+    ...intakeLine,
+    ...capabilityIntakeLine,
+    ...skillsLine,
+    ...governedActionExposureLine,
+    ...governedWorkspaceHygieneLine,
+    ...learningExperimentationLine,
+    ...browserCapabilityLine,
+    ...browserProofWorkflowLine,
+    ...safeRepairLine,
+    ...scopeRepairLine,
+    ...nextRunContinuityLine,
+    ...dataPermissionsLine,
+    ...deploymentEnvironmentLine,
+    ...aiEfficiencyRoutingLine,
+    ...supplyChainDependencyLine,
+    ...orchestrationLine,
+    ...outcomeEvidenceLine,
+    ...productionConfidenceLine,
+    ...valueSignalsLine,
+    ...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,
+    ...proofSavingsLines,
+  ];
+  return allLines.filter((line) => {
+    if (/^Activation:/i.test(line)) return true;
+    if (/^Agent readiness:/i.test(line)) return true;
+    if (/^Home:/i.test(line)) return true;
+    if (/^Capability intake:/i.test(line)) return true;
+    if (/\bNOT.?RUN\b/i.test(line)) return false;
+    if (/\bNO.?DATA\b/i.test(line)) return false;
+    if (/: PARTIAL\b/i.test(line)) return false;
+    if (/: partial\b/.test(line)) return false;
+    if (/latest receipt missing/i.test(line)) return false;
+    if (/receipt missing/i.test(line)) return false;
+    if (/reference source catalog/i.test(line)) return false;
+    if (/runner unavailable/i.test(line)) return false;
+    if (/needs attention/i.test(line)) return false;
+    if (/source catalog is missing/i.test(line)) return false;
+    return true;
+  }).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,
+    agentReadiness: status.agentReadiness || activation.agentReadiness || null,
+    productHome: status.productHome || null,
+    workspaceMap,
+    productLearning,
+    proMoment,
+    sessionContext,
+    governedWorkspaceHygiene: status.governedWorkspaceHygiene || null,
+    valueLedger,
+    contextSafety,
+    ...(status.agentSecurity ? { agentSecurity: status.agentSecurity } : {}),
+    ...(status.agentAccessGovernance ? { agentAccessGovernance: status.agentAccessGovernance } : {}),
+    ...(status.safePath ? { safePath: status.safePath } : {}),
+    ...(status.installIntakeRisk ? { installIntakeRisk: status.installIntakeRisk } : {}),
+    ...(status.capabilityIntake ? { capabilityIntake: status.capabilityIntake } : {}),
+    ...(status.skillsOperatingLayer ? { skillsOperatingLayer: status.skillsOperatingLayer } : {}),
+    ...(status.governedActionExposure ? { governedActionExposure: status.governedActionExposure } : {}),
+    ...(status.browserCapability ? { browserCapability: status.browserCapability } : {}),
+    ...(status.browserProofWorkflow ? { browserProofWorkflow: status.browserProofWorkflow } : {}),
+    ...(status.safeRepair ? { safeRepair: status.safeRepair } : {}),
+    ...(status.scopeRepair ? { scopeRepair: status.scopeRepair } : {}),
+    ...(status.nextRunContinuity ? { nextRunContinuity: status.nextRunContinuity } : {}),
+    ...(status.dataPermissions ? { dataPermissions: status.dataPermissions } : {}),
+    ...(status.deploymentEnvironment ? { deploymentEnvironment: status.deploymentEnvironment } : {}),
+    ...(status.supplyChainDependency ? { supplyChainDependency: status.supplyChainDependency } : {}),
+    ...(status.orchestration ? { orchestration: status.orchestration } : {}),
+    ...(status.outcomeEvidence ? { outcomeEvidence: status.outcomeEvidence } : {}),
+    ...(status.productionConfidence ? { productionConfidence: status.productionConfidence } : {}),
+    ...(status.valueSignals ? { valueSignals: status.valueSignals } : {}),
+    ...(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; }
+    })(),
+    proofSavings: (() => {
+      try {
+        const surface = buildProofSavingsSurface(cwd);
+        return {
+          evidenceQuality: surface.evidenceQuality,
+          estimatedSavings: surface.estimatedSavings,
+          openRisks: surface.openRisks,
+          nextBestAction: surface.nextBestAction,
+          validatedSignalCount: surface.validatedSignalCount,
+          savingsConfidence: surface.savingsConfidence,
+        };
+      } 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/cco-stop.js

@@ -0,0 +1,77 @@
+"use strict";
+
+const { readStdinJson, ensureCcoDirs, safeWriteJson } = require("./lib/fsx");
+const { normalizeHookInput } = require("./lib/hook-contracts");
+const { logMetric } = require("./lib/metrics");
+const { createCanonicalProof, createTaskContractProof, withCanonicalProof } = require("./lib/proof-canonical");
+
+function buildSafeStopMeta(input, outPath) {
+  return withCanonicalProof(
+    { outPath, reason: input.reason || "user-stop" },
+    createCanonicalProof("safe_stop", {
+      safe_stop_reason: input.reason || "user-stop",
+      progress_ref: outPath,
+      reentry_status: input.reentry_status || "reentry_available",
+      next_bounded_action: input.next_bounded_action || null,
+      rollback_available:
+        typeof input.rollback_available === "boolean"
+          ? input.rollback_available
+          : null,
+      claim_boundary: input.claim_boundary || null,
+      where_am_i_now: input.where_am_i_now || null,
+      progress_preserved: true,
+      reentry_anchor_saved: true,
+      evidence_refs: [outPath],
+    })
+  );
+}
+
+async function handleStop(rawInput) {
+  const input = normalizeHookInput(rawInput);
+  const cwd = input.cwd;
+  const sessionId = input.session_id;
+
+  ensureCcoDirs(cwd);
+  const taskContractProof = createTaskContractProof(input.task_contract);
+  if (taskContractProof) {
+    logMetric(cwd, {
+      sessionId,
+      event: "TaskContract",
+      action: "attached",
+      reasonCodes: [],
+      meta: withCanonicalProof(
+        { skipOutcomeEvent: true, taskId: input.task_id || null },
+        taskContractProof
+      ),
+    });
+  }
+  const outPath = `.claude/cco/state/stop-${Date.now()}.json`;
+  safeWriteJson(cwd, outPath, {
+    savedAt: new Date().toISOString(),
+    sessionId,
+    reason: input.reason || "user-stop",
+    message: input.message || "",
+    nextBoundedAction: input.next_bounded_action || null,
+  });
+
+  logMetric(cwd, {
+    sessionId,
+    event: "Stop",
+    action: "snapshot",
+    reasonCodes: ["STOP_SNAPSHOT"],
+    meta: buildSafeStopMeta(input, outPath),
+  });
+
+  return {};
+}
+
+async function main() {
+  const raw = await readStdinJson();
+  process.stdout.write(JSON.stringify(await handleStop(raw)));
+}
+
+main().catch(() => process.stdout.write(JSON.stringify({})));
+
+module.exports = {
+  handleStop,
+};