switchboard-cli 0.1.0-alpha.2 → 0.1.0-alpha.4

package/node_modules/@switchboard/core/src/reconcile-matrix.ts

@@ -1,154 +0,0 @@
-import type {
-  CheckMatrix,
-  CheckMatrixRow,
-  CheckResult,
-  GateState,
-  ProjectContract,
-  ReconcileReport,
-  ReconcileReviewPacket,
-  ReturnReport,
-} from "./types";
-import { checkMatrixSchema, reconcileReviewPacketSchema } from "./types";
-
-// ---------------------------------------------------------------------------
-// Check definitions — the 6 reconcile checks + 2 evidence checks
-// ---------------------------------------------------------------------------
-
-type CheckDef = {
-  name: string;
-  category: string;
-  why: string;
-};
-
-const CHECK_DEFS: CheckDef[] = [
-  { name: "Scope containment", category: "scope-inflation", why: "Ensures execution stayed within the agreed bounded slice." },
-  { name: "Non-goal boundaries", category: "non-goal-violation", why: "Protects declared boundaries from being crossed." },
-  { name: "Goal alignment", category: "goal-drift", why: "Confirms the work stayed aligned with the stated objective." },
-  { name: "Target user consistency", category: "target-user-shift", why: "Ensures the work serves the intended user, not a different one." },
-  { name: "Decision traceability", category: "untracked-decision", why: "Every decision should trace back to the contract, handoff, or brief." },
-  { name: "Evidence consistency", category: "evidence-contradiction", why: "Evidence should support, not contradict, the original problem." },
-];
-
-// ---------------------------------------------------------------------------
-// Derive check matrix from reconcile report + return
-// ---------------------------------------------------------------------------
-
-export function deriveCheckMatrix(input: {
-  reconcile: ReconcileReport;
-  latestReturn: ReturnReport;
-}): CheckMatrix {
-  const { reconcile, latestReturn } = input;
-  const rows: CheckMatrixRow[] = [];
-
-  for (const def of CHECK_DEFS) {
-    const findings = reconcile.findings.filter(f => f.category === def.category);
-    const hasBlocker = findings.some(f => f.severity === "review-required");
-
-    let result: CheckResult;
-    let evidence: string;
-
-    if (findings.length === 0) {
-      result = "pass";
-      evidence = "No issues detected.";
-    } else if (hasBlocker) {
-      result = "blocked";
-      evidence = findings.map(f => f.description).join(" ");
-    } else {
-      result = "caution";
-      evidence = findings.map(f => f.description).join(" ");
-    }
-
-    rows.push({
-      check: def.name,
-      result,
-      evidence: evidence.length > 150 ? evidence.slice(0, 147) + "…" : evidence,
-      why_it_matters: def.why,
-      contributes_to_gate: true,
-    });
-  }
-
-  // Evidence checks — from the return itself (not reconcile findings)
-  const verCount = latestReturn.verification_run.length;
-  const evCount = latestReturn.evidence.length;
-
-  rows.push({
-    check: "Verification evidence",
-    result: verCount > 0 ? "pass" : "missing",
-    evidence: verCount > 0
-      ? `${verCount} verification(s): ${latestReturn.verification_run.slice(0, 3).join(", ")}`
-      : "No verification checks were run.",
-    why_it_matters: "Verification proves the work was tested, not just claimed.",
-    contributes_to_gate: true,
-  });
-
-  rows.push({
-    check: "Supporting evidence",
-    result: evCount > 0 ? "pass" : "missing",
-    evidence: evCount > 0
-      ? `${evCount} item(s): ${latestReturn.evidence.slice(0, 3).join(", ")}`
-      : "No supporting evidence provided.",
-    why_it_matters: "Evidence backs claims of completion with concrete proof.",
-    contributes_to_gate: true,
-  });
-
-  const passCount = rows.filter(r => r.result === "pass").length;
-  const cautionCount = rows.filter(r => r.result === "caution").length;
-  const missingCount = rows.filter(r => r.result === "missing").length;
-  const blockedCount = rows.filter(r => r.result === "blocked").length;
-
-  return checkMatrixSchema.parse({
-    rows,
-    pass_count: passCount,
-    caution_count: cautionCount,
-    missing_count: missingCount,
-    blocked_count: blockedCount,
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Build review packet
-// ---------------------------------------------------------------------------
-
-export function buildReviewPacket(input: {
-  contract: ProjectContract;
-  reconcile: ReconcileReport;
-  latestReturn: ReturnReport;
-  gateState: GateState;
-  deltaSummary?: string;
-}): ReconcileReviewPacket {
-  const { contract, reconcile, latestReturn, gateState, deltaSummary } = input;
-
-  const matrix = deriveCheckMatrix({ reconcile, latestReturn });
-
-  const cautions = matrix.rows
-    .filter(r => r.result === "caution")
-    .map(r => `${r.check}: ${r.evidence}`);
-
-  const missing = matrix.rows
-    .filter(r => r.result === "missing")
-    .map(r => `${r.check}: ${r.evidence}`);
-
-  // Next resolution action
-  let next_resolution: string;
-  if (matrix.blocked_count > 0) {
-    const blocked = matrix.rows.filter(r => r.result === "blocked");
-    next_resolution = `Resolve ${blocked.length} blocked check(s): ${blocked.map(b => b.check).join(", ")}.`;
-  } else if (matrix.missing_count > 0) {
-    next_resolution = `Provide missing evidence for ${matrix.missing_count} check(s): ${missing.map(m => m.split(":")[0]).join(", ")}.`;
-  } else if (matrix.caution_count > 0) {
-    next_resolution = `Review ${matrix.caution_count} caution(s) before full acceptance.`;
-  } else {
-    next_resolution = "All checks pass. Ready for next bounded slice.";
-  }
-
-  return reconcileReviewPacketSchema.parse({
-    contract_summary: `${contract.title}: ${contract.one_liner}`,
-    delta_summary: deltaSummary ?? `${latestReturn.changed_files.length} file(s) changed. Status: ${latestReturn.status}. Objective: ${latestReturn.objective_met} met.`,
-    check_matrix: matrix,
-    cautions,
-    missing_evidence: missing,
-    gate_label: gateState.label,
-    gate_reason: gateState.reason,
-    next_resolution,
-  });
-}

package/node_modules/@switchboard/core/src/reconcile-v2.ts

@@ -1,272 +0,0 @@
-import type {
-  ProjectLedger,
-  ProvenanceRecord,
-  ReconcileCheckResult,
-  ReconcileV2Result,
-  ReturnReport,
-  TraceabilityCoverage,
-} from "./types";
-import { reconcileV2ResultSchema } from "./types";
-import { diffLedgers, goals, acceptanceCriteria, decisions, entriesByEvidence } from "./ledger";
-
-// ---------------------------------------------------------------------------
-// 1. Provenance minimums
-// ---------------------------------------------------------------------------
-
-function checkProvenance(provenance: ProvenanceRecord): ReconcileCheckResult {
-  const missing: string[] = [];
-
-  if (!provenance.spec_generation || provenance.spec_generation <= 0) missing.push("spec_generation");
-  if (provenance.outputs.length === 0) missing.push("outputs");
-  if (!provenance.agent_id) missing.push("agent_id");
-
-  if (missing.length > 0) {
-    return {
-      check: "provenance-minimums",
-      passed: false,
-      severity: "warning",
-      detail: `Missing provenance fields: ${missing.join(", ")}.`,
-    };
-  }
-
-  return { check: "provenance-minimums", passed: true, severity: "info", detail: "Provenance complete." };
-}
-
-// ---------------------------------------------------------------------------
-// 2. Requirement diff — unauthorized deltas
-// ---------------------------------------------------------------------------
-
-function checkRequirementDrift(
-  beforeLedger: ProjectLedger,
-  afterLedger: ProjectLedger,
-): ReconcileCheckResult {
-  const diff = diffLedgers(beforeLedger, afterLedger);
-
-  if (!diff.has_drift) {
-    return { check: "requirement-drift", passed: true, severity: "info", detail: "No requirement changes." };
-  }
-
-  // Removed requirements are blockers (unauthorized removal)
-  const removed = diff.entries.filter(d => d.action === "removed");
-  // Modified requirements are warnings
-  const modified = diff.entries.filter(d => d.action === "modified");
-  // Added decisions are ok if they have evidence
-  const added = diff.entries.filter(d => d.action === "added" && d.kind !== "decision");
-
-  if (removed.length > 0) {
-    return {
-      check: "requirement-drift",
-      passed: false,
-      severity: "blocker",
-      detail: `${removed.length} requirement(s) removed without approval. ${diff.summary}`,
-    };
-  }
-
-  if (modified.length > 0 || added.length > 0) {
-    return {
-      check: "requirement-drift",
-      passed: false,
-      severity: "warning",
-      detail: diff.summary,
-    };
-  }
-
-  return { check: "requirement-drift", passed: true, severity: "info", detail: diff.summary };
-}
-
-// ---------------------------------------------------------------------------
-// 3. Traceability coverage
-// ---------------------------------------------------------------------------
-
-function checkTraceability(
-  ledger: ProjectLedger,
-  report: ReturnReport,
-): { check: ReconcileCheckResult; coverage: TraceabilityCoverage[] } {
-  const toTrace = [...goals(ledger), ...acceptanceCriteria(ledger)];
-  const artifacts = new Set([
-    ...report.changed_files.map(f => f.toLowerCase()),
-    ...report.artifacts_created.map(a => a.toLowerCase()),
-    ...report.verification_run.map(v => v.toLowerCase()),
-  ]);
-
-  const coverage: TraceabilityCoverage[] = toTrace.map(entry => {
-    // Check if any artifact/file/test keywords match the entry
-    const entryWords = entry.text.toLowerCase().split(/\s+/).filter(w => w.length > 3);
-    const linked: string[] = [];
-
-    for (const art of artifacts) {
-      if (entryWords.some(w => art.includes(w))) {
-        linked.push(art);
-      }
-    }
-
-    return {
-      entry_id: entry.id,
-      entry_text: entry.text,
-      linked_artifacts: linked,
-      covered: linked.length > 0,
-    };
-  });
-
-  const uncovered = coverage.filter(c => !c.covered);
-
-  if (uncovered.length === 0) {
-    return {
-      check: { check: "traceability-coverage", passed: true, severity: "info", detail: `${coverage.length}/${coverage.length} requirements traced.` },
-      coverage,
-    };
-  }
-
-  return {
-    check: {
-      check: "traceability-coverage",
-      passed: false,
-      severity: uncovered.length > coverage.length / 2 ? "blocker" : "warning",
-      detail: `${coverage.length - uncovered.length}/${coverage.length} requirements traced. ${uncovered.length} orphan(s).`,
-    },
-    coverage,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// 4. Decision evidence parenting
-// ---------------------------------------------------------------------------
-
-function checkDecisionEvidence(ledger: ProjectLedger): ReconcileCheckResult {
-  const decs = decisions(ledger);
-  const unparented = decs.filter(d =>
-    d.evidence_type === "weak-inference" && d.evidence_refs.length === 0,
-  );
-
-  if (unparented.length === 0) {
-    return { check: "decision-evidence", passed: true, severity: "info", detail: `${decs.length} decision(s) all have evidence.` };
-  }
-
-  return {
-    check: "decision-evidence",
-    passed: false,
-    severity: "warning",
-    detail: `${unparented.length}/${decs.length} decision(s) lack evidence or parent requirement.`,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// 5. Citation existence verification
-// ---------------------------------------------------------------------------
-
-function checkCitationExistence(ledger: ProjectLedger): ReconcileCheckResult {
-  const researchBacked = entriesByEvidence(ledger, "research-backed");
-  const missingCitation = researchBacked.filter(e => e.evidence_refs.length === 0);
-
-  if (researchBacked.length === 0) {
-    return { check: "citation-existence", passed: true, severity: "info", detail: "No research-backed entries." };
-  }
-
-  if (missingCitation.length === 0) {
-    return { check: "citation-existence", passed: true, severity: "info", detail: `${researchBacked.length} research-backed entries all have citations.` };
-  }
-
-  return {
-    check: "citation-existence",
-    passed: false,
-    severity: "warning",
-    detail: `${missingCitation.length}/${researchBacked.length} research-backed entries missing citation references.`,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// 6. Execution evidence enforcement
-// ---------------------------------------------------------------------------
-
-function checkExecutionEvidence(report: ReturnReport): ReconcileCheckResult {
-  const claimsDone = report.status === "done" || report.objective_met === "yes";
-
-  if (!claimsDone) {
-    return { check: "execution-evidence", passed: true, severity: "info", detail: "Return does not claim completion." };
-  }
-
-  const hasVerification = report.verification_run.length > 0;
-  const hasEvidence = report.evidence.length > 0;
-  const hasSuccessCriteria = report.success_criteria_met.length > 0;
-
-  if (!hasVerification && !hasEvidence) {
-    return {
-      check: "execution-evidence",
-      passed: false,
-      severity: "blocker",
-      detail: "Claims done but has no verification_run and no evidence.",
-    };
-  }
-
-  if (!hasSuccessCriteria) {
-    return {
-      check: "execution-evidence",
-      passed: false,
-      severity: "warning",
-      detail: "Claims done but reports no success_criteria_met.",
-    };
-  }
-
-  return {
-    check: "execution-evidence",
-    passed: true,
-    severity: "info",
-    detail: `${report.verification_run.length} verification(s), ${report.evidence.length} evidence item(s), ${report.success_criteria_met.length} criteria met.`,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Full Reconcile V2
-// ---------------------------------------------------------------------------
-
-export function reconcileV2(input: {
-  report: ReturnReport;
-  provenance: ProvenanceRecord;
-  ledgerBefore: ProjectLedger;
-  ledgerAfter: ProjectLedger;
-}): ReconcileV2Result {
-  const checks: ReconcileCheckResult[] = [];
-
-  // 1. Provenance minimums
-  checks.push(checkProvenance(input.provenance));
-
-  // 2. Requirement drift
-  checks.push(checkRequirementDrift(input.ledgerBefore, input.ledgerAfter));
-
-  // 3. Traceability
-  const { check: traceCheck, coverage } = checkTraceability(input.ledgerAfter, input.report);
-  checks.push(traceCheck);
-
-  // 4. Decision evidence
-  checks.push(checkDecisionEvidence(input.ledgerAfter));
-
-  // 5. Citation existence
-  checks.push(checkCitationExistence(input.ledgerAfter));
-
-  // 6. Execution evidence
-  checks.push(checkExecutionEvidence(input.report));
-
-  // Aggregate
-  const blockers = checks.filter(c => !c.passed && c.severity === "blocker").length;
-  const warnings = checks.filter(c => !c.passed && c.severity === "warning").length;
-  const passed = blockers === 0;
-  const recommendation = blockers > 0 ? "review-required" : warnings > 0 ? "accept-with-warnings" : "accept";
-
-  const summaryParts: string[] = [];
-  if (blockers > 0) summaryParts.push(`${blockers} blocker(s)`);
-  if (warnings > 0) summaryParts.push(`${warnings} warning(s)`);
-  const failedChecks = checks.filter(c => !c.passed);
-  if (failedChecks.length > 0) {
-    summaryParts.push(failedChecks.map(c => c.check).join(", "));
-  }
-
-  return reconcileV2ResultSchema.parse({
-    checks,
-    traceability: coverage,
-    passed,
-    blockers,
-    warnings,
-    recommendation,
-    summary: summaryParts.length > 0 ? summaryParts.join(". ") + "." : "All checks passed.",
-  });
-}