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

package/node_modules/@switchboard/core/src/activation.ts

@@ -0,0 +1,285 @@
+import type {
+  ActivationInput,
+  ActivationResult,
+  Assumption,
+  DangerousGate,
+  ModeScoring,
+  NonFunctionalGate,
+  ProcessMode,
+  SynthesizedSeed,
+  WorkflowCanvas,
+} from "./types";
+import { activationResultSchema } from "./types";
+
+function compact(text: string): string {
+  return text.replace(/\s+/g, " ").trim();
+}
+
+let _ctr = 0;
+function aId(): string { return `asmp-${++_ctr}-${Date.now().toString(36)}`; }
+
+// ---------------------------------------------------------------------------
+// 1. Assumption Register
+// ---------------------------------------------------------------------------
+
+export function buildAssumptions(seed: SynthesizedSeed, input: ActivationInput): Assumption[] {
+  const assumptions: Assumption[] = [];
+
+  // Open questions → unconfirmed assumptions
+  for (const q of seed.open_questions) {
+    assumptions.push({
+      id: aId(), text: q, status: "unconfirmed",
+      evidence_type: "weak-inference", risk_level: "medium", source: "user-question",
+    });
+  }
+
+  // Missing inputs → high-risk unconfirmed assumptions
+  for (const m of seed.missing_inputs) {
+    assumptions.push({
+      id: aId(), text: m, status: "unconfirmed",
+      evidence_type: "weak-inference", risk_level: "high", source: "missing-input",
+    });
+  }
+
+  // If target user is generic → assumption about audience
+  if (seed.target_user === "Solo builders shipping software.") {
+    assumptions.push({
+      id: aId(), text: "Target user is assumed to be solo builders (not explicitly stated).",
+      status: "unconfirmed", evidence_type: "weak-inference", risk_level: "medium", source: "inference",
+    });
+  }
+
+  // If no repo → assumption about starting fresh
+  if (!input.repo_exists) {
+    assumptions.push({
+      id: aId(), text: "No existing codebase — starting from scratch.",
+      status: "confirmed", evidence_type: "user-backed", risk_level: "low", source: "user-input",
+    });
+  }
+
+  return assumptions;
+}
+
+// ---------------------------------------------------------------------------
+// 2. Workflow Grounding Canvas
+// ---------------------------------------------------------------------------
+
+const USER_PATTERNS = [
+  /\bfor\s+([^.,;!?\n]{4,60}?)(?:\s+(?:that|who|which))/i,
+  /\bfor\s+([^.,;!?\n]{4,60})/i,
+  /\btargeting\s+([^.,;!?\n]{4,60})/i,
+];
+
+const CURRENT_WORKFLOW_PATTERNS = [
+  /(?:right now|currently|today)[,:]?\s+(.{15,150})/i,
+  /(?:we|I)\s+(?:currently|already)\s+(.{10,100})/i,
+  /(?:the current|our current)\s+(.{10,100})/i,
+];
+
+const TARGET_WORKFLOW_PATTERNS = [
+  /(?:I want|we want|should be able to|the user should)\s+(.{10,150})/i,
+  /(?:instead of|rather than)\s+.{5,50}?,?\s*(.{10,100})/i,
+];
+
+const JOB_PATTERNS = [
+  /(?:the core outcome|the goal|the job|what I want)\s+(?:is|I want)[:\s]+(.{10,150})/i,
+  /(?:so that|in order to)\s+(.{10,100})/i,
+];
+
+export function buildWorkflowCanvas(raw: string, seed: SynthesizedSeed): WorkflowCanvas {
+  let primary_user = "";
+  for (const p of USER_PATTERNS) {
+    const m = raw.match(p);
+    if (m?.[1] && m[1].length > 5) { primary_user = compact(m[1]); break; }
+  }
+  if (!primary_user && seed.target_user !== "Solo builders shipping software.") {
+    primary_user = seed.target_user;
+  }
+
+  let current_workflow = "";
+  for (const p of CURRENT_WORKFLOW_PATTERNS) {
+    const m = raw.match(p);
+    if (m?.[1]) { current_workflow = compact(m[1]).slice(0, 150); break; }
+  }
+
+  let target_workflow = "";
+  for (const p of TARGET_WORKFLOW_PATTERNS) {
+    const m = raw.match(p);
+    if (m?.[1]) { target_workflow = compact(m[1]).slice(0, 150); break; }
+  }
+
+  let job_to_be_done = seed.v1_outcome || "";
+  for (const p of JOB_PATTERNS) {
+    const m = raw.match(p);
+    if (m?.[1] && m[1].length > 15) { job_to_be_done = compact(m[1]).slice(0, 150); break; }
+  }
+
+  return { primary_user, current_workflow, target_workflow, job_to_be_done, edge_cases: [] };
+}
+
+// ---------------------------------------------------------------------------
+// 3. Non-functional gates
+// ---------------------------------------------------------------------------
+
+const NF_PATTERNS: { category: NonFunctionalGate["category"]; patterns: RegExp[]; reason: string }[] = [
+  { category: "security", patterns: [/\bauth\b/i, /\bpassword\b/i, /\btoken\b/i, /\bOAuth\b/i, /\bencrypt/i, /\bAPI\s*key\b/i], reason: "Auth/security-related functionality detected." },
+  { category: "privacy", patterns: [/\bPII\b/i, /\bpersonal\s+data\b/i, /\bGDPR\b/i, /\bemail\s+address/i, /\buser\s+data\b/i], reason: "Personal/user data handling detected." },
+  { category: "compliance", patterns: [/\bcompliance\b/i, /\bregulatory\b/i, /\bHIPAA\b/i, /\bSOC\s*2\b/i, /\blegal\b/i], reason: "Compliance-relevant domain detected." },
+  { category: "performance", patterns: [/\breal.?time\b/i, /\blatency\b/i, /\bscale\b/i, /\bconcurren/i, /\bstreaming\b/i], reason: "Performance-sensitive requirements detected." },
+  { category: "observability", patterns: [/\blogging\b/i, /\bmonitoring\b/i, /\balert/i, /\bmetric/i, /\btrac(?:e|ing)\b/i], reason: "Observability-relevant functionality detected." },
+];
+
+export function checkNonFunctionalGates(raw: string, constraints: string): NonFunctionalGate[] {
+  const combined = `${raw} ${constraints}`;
+  const gates: NonFunctionalGate[] = [];
+
+  for (const nf of NF_PATTERNS) {
+    const triggered = nf.patterns.some(p => p.test(combined));
+    if (triggered) {
+      gates.push({
+        category: nf.category,
+        flagged: true,
+        reason: nf.reason,
+        severity: nf.category === "security" || nf.category === "privacy" ? "medium" : "low",
+      });
+    }
+  }
+
+  return gates;
+}
+
+// ---------------------------------------------------------------------------
+// 4. Dangerous gates
+// ---------------------------------------------------------------------------
+
+export function checkDangerousGates(raw: string, constraints: string, seed: SynthesizedSeed): DangerousGate[] {
+  const combined = compact(`${raw} ${constraints}`).toLowerCase();
+  const gates: DangerousGate[] = [];
+
+  // Privacy high-risk
+  if (/\b(medical|health|financial|banking|credit\s*card|SSN|social\s*security)\b/i.test(combined)) {
+    gates.push({ gate: "privacy-high-risk", triggered: true, reason: "Domain involves sensitive personal/financial/medical data." });
+  }
+
+  // Trust boundary uncertainty
+  if (seed.missing_inputs.some(m => /target user/i.test(m)) || seed.target_user === "Solo builders shipping software.") {
+    if (/\b(team|enterprise|organization|company|admin)\b/i.test(combined) && !/\bnot?\s+(?:a\s+)?(?:team|enterprise)/i.test(combined)) {
+      gates.push({ gate: "trust-boundary-uncertain", triggered: true, reason: "Multi-user/team context with unclear trust boundaries." });
+    }
+  }
+
+  // Production-critical
+  if (/\b(production|prod|live\s+system|critical\s+path|payment|billing)\b/i.test(combined)) {
+    if (!/\bno\s+billing\b/i.test(combined) && !/\bno\s+payment\b/i.test(combined)) {
+      gates.push({ gate: "production-critical", triggered: true, reason: "Production-critical or payment-adjacent functionality." });
+    }
+  }
+
+  // Overbroad + missing stop condition
+  const systemCount = (combined.match(/\b(slack|jira|github|linear|hubspot|notion|email|stripe|twilio)\b/gi) ?? []).length;
+  const hasStopCondition = /\bv1\b|\bfirst\s+slice\b|\bonly\b|\bjust\b|\bsimple\b|\bnarrow\b/i.test(combined);
+  if (systemCount >= 4 && !hasStopCondition) {
+    gates.push({ gate: "overbroad-no-stop", triggered: true, reason: `${systemCount} systems mentioned with no clear V1 narrowing.` });
+  }
+
+  return gates;
+}
+
+// ---------------------------------------------------------------------------
+// 5. Mode scoring
+// ---------------------------------------------------------------------------
+
+export function scoreMode(raw: string, constraints: string, seed: SynthesizedSeed): ModeScoring {
+  const combined = compact(`${raw} ${constraints}`).toLowerCase();
+
+  const surface_area = combined.length > 500 ? 2 : combined.length > 200 ? 1 : 0;
+
+  const integrations = (combined.match(/\b(slack|jira|github|linear|hubspot|notion|email|supabase|stripe|firebase|aws)\b/gi) ?? []);
+  const integration_count = Math.min(integrations.length, 3);
+
+  const user_clarity = seed.target_user !== "Solo builders shipping software." ? 0 : 2;
+
+  const outcome_concreteness = seed.v1_outcome && seed.v1_outcome.length > 20 ? 0 : seed.v1_outcome ? 1 : 3;
+
+  const coordination_complexity = /\b(team|across\s+teams|coordinate|orchestrat)\b/i.test(combined) ? 2 : 0;
+
+  const contradictions = seed.missing_inputs.filter(m => /contradict|conflicting/i.test(m)).length;
+  const contradiction_level = Math.min(contradictions, 3);
+
+  const appetite_mismatch = /\b(two\s+weeks|one\s+week|weekend)\b/i.test(combined) && integration_count >= 2 ? 2 : 0;
+
+  const total = surface_area + integration_count + user_clarity + outcome_concreteness +
+    coordination_complexity + contradiction_level + appetite_mismatch;
+
+  return { surface_area, integration_count, user_clarity, outcome_concreteness,
+    coordination_complexity, contradiction_level, appetite_mismatch, total };
+}
+
+// ---------------------------------------------------------------------------
+// 6. Two-stage mode selection
+// ---------------------------------------------------------------------------
+
+export function selectModeV2(
+  dangerousGates: DangerousGate[],
+  scoring: ModeScoring,
+): { mode: ProcessMode; reason: string } {
+  // Stage 1: Dangerous gates → governance
+  const triggered = dangerousGates.filter(g => g.triggered);
+  if (triggered.length > 0) {
+    return {
+      mode: "governance",
+      reason: `Dangerous gate(s): ${triggered.map(g => g.gate).join(", ")}.`,
+    };
+  }
+
+  // Stage 2: Scoring → simple vs standard
+  if (scoring.total <= 3) {
+    return { mode: "minimal", reason: `Low complexity score (${scoring.total}/21). Lightweight process.` };
+  }
+  if (scoring.total >= 10) {
+    return { mode: "governance", reason: `High complexity score (${scoring.total}/21). Careful review recommended.` };
+  }
+
+  return { mode: "structured", reason: `Standard complexity score (${scoring.total}/21).` };
+}
+
+// ---------------------------------------------------------------------------
+// 7. Escalation triggers
+// ---------------------------------------------------------------------------
+
+export function checkEscalationTriggers(raw: string): string[] {
+  const triggers: string[] = [];
+  if (/\btrust\s+boundar/i.test(raw)) triggers.push("Trust boundaries appeared.");
+  if ((raw.match(/\b(slack|jira|github|linear|hubspot|notion|email|supabase|stripe)\b/gi) ?? []).length >= 3) {
+    triggers.push("Integration count materially increased.");
+  }
+  if (/\b(and also|plus|additionally)\s+(?:for|targeting)\s/i.test(raw)) triggers.push("Target users may have split.");
+  if (/\b(and also|plus|additionally)\s+(?:build|add|create)\s/i.test(raw)) triggers.push("Scope may have expanded materially.");
+  if (/\b(HIPAA|GDPR|SOC|PCI|encrypt|sensitive\s+data)\b/i.test(raw)) triggers.push("Privacy/security risk increased.");
+  return triggers;
+}
+
+// ---------------------------------------------------------------------------
+// Full Activation V2
+// ---------------------------------------------------------------------------
+
+export function activateV2(input: ActivationInput, seed: SynthesizedSeed): ActivationResult {
+  const assumptions = buildAssumptions(seed, input);
+  const workflow_canvas = buildWorkflowCanvas(input.raw_idea, seed);
+  const non_functional_gates = checkNonFunctionalGates(input.raw_idea, input.constraints);
+  const dangerous_gates = checkDangerousGates(input.raw_idea, input.constraints, seed);
+  const mode_scoring = scoreMode(input.raw_idea, input.constraints, seed);
+  const { mode } = selectModeV2(dangerous_gates, mode_scoring);
+  const escalation_triggers = checkEscalationTriggers(input.raw_idea);
+
+  return activationResultSchema.parse({
+    assumptions,
+    workflow_canvas,
+    non_functional_gates,
+    dangerous_gates,
+    mode_scoring,
+    selected_mode: mode,
+    mode_is_escalatable: true,
+    escalation_triggers,
+  });
+}

package/node_modules/@switchboard/core/src/audited-receipt.ts

@@ -0,0 +1,403 @@
+import { randomBytes } from "crypto";
+import type {
+  AuditedReceipt,
+  AuditResult,
+  CanonicalDelta,
+  ClaimAssessment,
+  ClaimDisposition,
+  GateState,
+  NextSlice,
+  NormalizedReturnEnvelope,
+  TrustPosture,
+} from "./types";
+import { auditedReceiptSchema } from "./types";
+import { deriveControlFlags } from "./run-snapshot";
+import type { TraceSummary } from "./execution-trace";
+import type { BudgetSummary } from "./budget-ledger";
+import type { OverflowSummary } from "./types";
+
+// ---------------------------------------------------------------------------
+// Audited Receipt — the official product-level receipt
+// ---------------------------------------------------------------------------
+//
+// The audited receipt is what the system trusts. It is built from:
+//   - NormalizedReturnEnvelope (what the agent claimed)
+//   - CanonicalDelta (what actually changed, with evidence accounting)
+//   - GateState (the gate's verdict on the evidence)
+//   - NextSlice (what comes next, if anything)
+//
+// It explicitly distinguishes:
+//   - what was claimed
+//   - what was actually proven
+//   - what remains partial / inferred / weak
+//   - what cautions and residuals carry forward
+//   - whether closure is allowed
+//   - whether canonical state advanced, and on what basis
+// ---------------------------------------------------------------------------
+
+export interface BuildAuditedReceiptInput {
+  envelope: NormalizedReturnEnvelope;
+  delta: CanonicalDelta;
+  gate: GateState;
+  nextSlice: NextSlice | null;
+  projectId?: string;
+  /** Audit result, when available. Feeds explicit audit findings onto the receipt. */
+  audit?: AuditResult | null;
+  /** Trace summary from execution-trace module, when available. */
+  traceSummary?: TraceSummary | null;
+  /** Budget summary from budget-ledger module, when available. */
+  budgetSummary?: BudgetSummary | null;
+  /** Overflow summary from overflow-manifest module, when available. */
+  overflowSummary?: OverflowSummary | null;
+}
+
+// ---------------------------------------------------------------------------
+// Claim assessment — classifies each significant claim by evidence strength
+// ---------------------------------------------------------------------------
+
+function assessClaims(
+  envelope: NormalizedReturnEnvelope,
+  delta: CanonicalDelta,
+): ClaimAssessment[] {
+  const assessments: ClaimAssessment[] = [];
+
+  // Pool of structured evidence for matching
+  const verificationPool = new Set(
+    delta.verification_runs.map(v => v.toLowerCase()),
+  );
+  const evidencePool = new Set(
+    delta.evidence_items.map(e => e.toLowerCase()),
+  );
+  const criteriaPool = new Set(
+    (delta.evidence_accounting?.criteria_met ?? []).map(c => c.toLowerCase()),
+  );
+
+  function classify(text: string): { disposition: ClaimDisposition; basis: string } {
+    const lower = text.toLowerCase();
+    const words = lower.split(/\s+/).filter(w => w.length > 3);
+    const fullMatchThreshold = words.length <= 2 ? 1 : 2;
+
+    // Track best partial match across all pools for fallback to "partial"
+    let bestPartialLine = "";
+    let bestPartialScore = 0;
+    let bestPartialPool = "";
+
+    // Check verification runs
+    for (const v of verificationPool) {
+      const matchCount = words.filter(w => v.includes(w)).length;
+      if (matchCount >= fullMatchThreshold) {
+        return { disposition: "proven", basis: `Matched verification: ${v.slice(0, 80)}` };
+      }
+      if (matchCount > bestPartialScore) {
+        bestPartialScore = matchCount;
+        bestPartialLine = v;
+        bestPartialPool = "verification";
+      }
+    }
+
+    // Check evidence items
+    for (const e of evidencePool) {
+      const matchCount = words.filter(w => e.includes(w)).length;
+      if (matchCount >= fullMatchThreshold) {
+        return { disposition: "supported", basis: `Matched evidence: ${e.slice(0, 80)}` };
+      }
+      if (matchCount > bestPartialScore) {
+        bestPartialScore = matchCount;
+        bestPartialLine = e;
+        bestPartialPool = "evidence";
+      }
+    }
+
+    // Check criteria met
+    for (const c of criteriaPool) {
+      const matchCount = words.filter(w => c.includes(w)).length;
+      if (matchCount >= fullMatchThreshold) {
+        return { disposition: "supported", basis: `Matched criterion: ${c.slice(0, 80)}` };
+      }
+      if (matchCount > bestPartialScore) {
+        bestPartialScore = matchCount;
+        bestPartialLine = c;
+        bestPartialPool = "criterion";
+      }
+    }
+
+    // Partial: at least 1 keyword matched but not enough for full supported/proven
+    if (bestPartialScore >= 1) {
+      return {
+        disposition: "partial",
+        basis: `Partial ${bestPartialPool} match (${bestPartialScore}/${words.length} keywords): ${bestPartialLine.slice(0, 80)}`,
+      };
+    }
+
+    // Content mode from envelope — inferred items get "inferred" disposition
+    const envelopeItem = envelope.evidence_items.find(
+      ei => ei.text.toLowerCase() === lower,
+    );
+    if (envelopeItem && (envelopeItem.content_mode === "inferred" || envelopeItem.content_mode === "reconstructed")) {
+      return { disposition: "inferred", basis: `Content mode: ${envelopeItem.content_mode}` };
+    }
+
+    return { disposition: "unsubstantiated", basis: "No matching structured evidence found." };
+  }
+
+  // Assess the summary claim (the primary output statement)
+  if (envelope.summary) {
+    const result = classify(envelope.summary);
+    assessments.push({ claim: envelope.summary, ...result });
+  }
+
+  // Assess each success criterion claimed
+  for (const criterion of envelope.criteria_met) {
+    const result = classify(criterion.text);
+    assessments.push({ claim: criterion.text, ...result });
+  }
+
+  // Assess each decision made
+  for (const decision of envelope.decisions) {
+    const result = classify(decision.text);
+    assessments.push({ claim: decision.text, ...result });
+  }
+
+  return assessments;
+}
+
+// ---------------------------------------------------------------------------
+// Trust posture — overall trust level derived from gate + evidence + residuals
+// ---------------------------------------------------------------------------
+
+function deriveTrustPosture(
+  gate: GateState,
+  residualCount: number,
+): { posture: TrustPosture; basis: string } {
+  switch (gate.label) {
+    case "accepted":
+      if (residualCount === 0) {
+        return {
+          posture: "verified",
+          basis: `Gate accepted. ${gate.evidence_summary.verification_count} verification(s), ${gate.evidence_summary.evidence_count} evidence item(s). No residuals.`,
+        };
+      }
+      return {
+        posture: "cautioned",
+        basis: `Gate accepted but ${residualCount} residual(s) carry forward.`,
+      };
+
+    case "accepted-with-cautions":
+      return {
+        posture: "cautioned",
+        basis: gate.reason,
+      };
+
+    case "held-for-review":
+      return {
+        posture: "held",
+        basis: gate.reason,
+      };
+
+    case "blocked-missing-evidence":
+      return {
+        posture: "blocked",
+        basis: gate.reason,
+      };
+
+    case "pending":
+    case "not-checked":
+      return {
+        posture: "unknown",
+        basis: gate.reason,
+      };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Closure basis — why closure is or isn't allowed
+// ---------------------------------------------------------------------------
+
+function deriveClosureBasis(
+  closureAllowed: boolean,
+  gate: GateState,
+  delta: CanonicalDelta,
+): string {
+  if (closureAllowed) {
+    if (delta.objective_state === "met" && delta.unresolved.length === 0) {
+      return "Objective met, gate passed, no unresolved items.";
+    }
+    return `Gate: ${gate.label}. Closure permitted despite ${delta.unresolved.length} unresolved item(s).`;
+  }
+
+  const reasons: string[] = [];
+  if (gate.label === "held-for-review") reasons.push("Gate held for review");
+  if (gate.label === "blocked-missing-evidence") reasons.push("Gate blocked — missing evidence");
+  if (delta.unresolved.length > 0) reasons.push(`${delta.unresolved.length} unresolved item(s)`);
+  if (reasons.length === 0) reasons.push("Pre-return phase — no return to close");
+
+  return reasons.join(". ") + ".";
+}
+
+// ---------------------------------------------------------------------------
+// Advancement basis — what caused canonical state to advance
+// ---------------------------------------------------------------------------
+
+function deriveAdvancementBasis(delta: CanonicalDelta): { advanced: boolean; basis: string } {
+  const ea = delta.evidence_accounting;
+  if (!ea) {
+    // No evidence accounting — check state_fields_advanced
+    if (delta.state_fields_advanced.length > 0) {
+      return { advanced: true, basis: delta.state_fields_advanced.join("; ") };
+    }
+    return { advanced: false, basis: "No evidence accounting available." };
+  }
+
+  if (ea.consequence_type === "no-change") {
+    return { advanced: false, basis: ea.consequence_label };
+  }
+
+  return { advanced: true, basis: ea.consequence_label };
+}
+
+// ---------------------------------------------------------------------------
+// Primary builder — assembles the audited receipt from component objects
+// ---------------------------------------------------------------------------
+
+export function buildAuditedReceipt(input: BuildAuditedReceiptInput): AuditedReceipt {
+  const { envelope, delta, gate, nextSlice, projectId = "", audit, traceSummary, budgetSummary, overflowSummary } = input;
+
+  // Claim assessments
+  const claim_assessments = assessClaims(envelope, delta);
+
+  // Evidence counts from delta's evidence accounting (single source of truth)
+  const ea = delta.evidence_accounting;
+  const verification_count = ea?.verification_run_count ?? delta.verification_runs.length;
+  const evidence_count = ea?.evidence_item_count ?? delta.evidence_items.length;
+  const criteria_met_count = ea?.criteria_met_count ?? 0;
+  const files_changed_count = ea?.file_change_count ?? delta.file_changes.length;
+
+  // --- Explicit audit findings (matches RunSnapshot pattern) ---
+  const audit_required = audit?.audit_required ?? false;
+  const audit_cautions: string[] = [];
+  const audit_blockers: string[] = [];
+  if (audit) {
+    for (const f of audit.findings) {
+      if (f.severity === "caution") {
+        audit_cautions.push(`[audit] ${f.detail}`);
+      } else if (f.severity === "blocker") {
+        audit_blockers.push(`[audit-blocker] ${f.detail}`);
+      }
+    }
+  }
+  const audit_finding_count = audit_cautions.length + audit_blockers.length;
+
+  // Residuals — delta cautions + audit cautions merged (single source of truth)
+  const cautions_on_record = [...delta.cautions, ...audit_cautions, ...audit_blockers];
+  const unresolved_on_record = delta.unresolved;
+  const residual_count = cautions_on_record.length + unresolved_on_record.length;
+
+  // Trust posture
+  const { posture: trust_posture, basis: trust_basis } = deriveTrustPosture(gate, residual_count);
+
+  // Closure — use shared control-flag logic
+  const phase = gate.label === "accepted" ? "accepted" as const
+    : gate.label === "accepted-with-cautions" ? "accepted_with_cautions" as const
+    : gate.label === "held-for-review" ? "held_for_review" as const
+    : gate.label === "blocked-missing-evidence" ? "blocked" as const
+    : "return_received" as const;
+  const { closureAllowed } = deriveControlFlags(phase, true);
+  const closure_basis = deriveClosureBasis(closureAllowed, gate, delta);
+
+  // Advancement
+  const { advanced: state_advanced, basis: advancement_basis } = deriveAdvancementBasis(delta);
+  const consequence_type = ea?.consequence_type ?? "no-change";
+  const consequence_label = ea?.consequence_label ?? "No evidence accounting available.";
+
+  return auditedReceiptSchema.parse({
+    // Identity
+    receipt_id: `aud-${randomBytes(8).toString("hex")}`,
+    receipt_version: 1,
+    created_at: new Date().toISOString(),
+    project_id: projectId || delta.project_id,
+    dispatch_id: envelope.dispatch_id,
+    return_id: envelope.return_id,
+    envelope_id: envelope.envelope_id,
+    delta_id: delta.delta_id,
+
+    // Claimed
+    objective_claimed: envelope.objective_used,
+    outcome_claimed: envelope.outcome_class,
+    summary_claimed: envelope.summary,
+
+    // Proven
+    verification_count,
+    evidence_count,
+    criteria_met_count,
+    files_changed_count,
+    claim_assessments,
+
+    // Gate
+    gate_label: gate.label,
+    gate_reason: gate.reason,
+    gate_honest: gate.honest,
+
+    // Provenance
+    provenance_posture: envelope.provenance_posture,
+    confidence_posture: envelope.confidence_posture,
+
+    // Closure
+    closure_allowed: closureAllowed,
+    closure_basis,
+
+    // Audit findings (explicit, not just reflected in gate)
+    audit_required,
+    audit_finding_count,
+    audit_cautions,
+    audit_blockers,
+
+    // Residuals
+    cautions_on_record,
+    unresolved_on_record,
+    residual_count,
+
+    // Advancement
+    state_advanced,
+    advancement_basis,
+    consequence_type,
+    consequence_label,
+
+    // Next slice (with basis)
+    next_slice_exists: !!nextSlice,
+    next_slice_id: nextSlice?.slice_id ?? "",
+    next_slice_title: nextSlice?.title ?? "",
+    next_slice_ready: nextSlice?.dispatch_ready ?? false,
+    next_slice_why: nextSlice?.why_next ?? "",
+    next_slice_blocking_reason: nextSlice?.blocking_reason ?? "",
+
+    // Execution trace summary
+    trace_step_count: traceSummary?.trace_step_count ?? 0,
+    trace_tool_use_count: traceSummary?.trace_tool_use_count ?? 0,
+    trace_failure_phase: traceSummary?.trace_failure_phase ?? "",
+    trace_error_category: traceSummary?.trace_error_category ?? "",
+    trace_duration_ms: traceSummary?.trace_duration_ms ?? 0,
+    trace_available: traceSummary?.trace_available ?? false,
+
+    // Budget breakdown
+    budget_task_steps: budgetSummary?.task_steps ?? 0,
+    budget_task_tool_uses: budgetSummary?.task_tool_uses ?? 0,
+    budget_verification_steps: budgetSummary?.verification_steps ?? 0,
+    budget_verification_tool_uses: budgetSummary?.verification_tool_uses ?? 0,
+    budget_correction_steps: budgetSummary?.correction_steps ?? 0,
+    budget_correction_tool_uses: budgetSummary?.correction_tool_uses ?? 0,
+    budget_overhead_ratio: budgetSummary?.overhead_ratio ?? 0,
+    budget_had_corrections: budgetSummary?.had_corrections ?? false,
+    budget_posture: budgetSummary?.budget_posture ?? "unknown",
+    budget_posture_basis: budgetSummary?.budget_posture_basis ?? "",
+
+    // Overflow / progressive disclosure
+    overflow_entry_count: overflowSummary?.overflow_entry_count ?? 0,
+    overflow_total_bytes: overflowSummary?.overflow_total_bytes ?? 0,
+    overflow_sources: overflowSummary?.overflow_sources ?? [],
+    overflow_available: overflowSummary?.overflow_available ?? false,
+
+    // Trust
+    trust_posture,
+    trust_basis,
+  });
+}