percolation-inversion-compiler-ts 0.4.5 → 0.5.0

package/dist/index.js

@@ -658,19 +658,1583 @@ function agentRunbookSteps(profile = "development") {
   ];
 }
 
+// src/phase_lab/index.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync5,
+  readdirSync as readdirSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { basename as basename2, join as join4 } from "path";
+var PHASE_LAB_SAFETY = [
+  "phase lab stores local report data only",
+  "phase lab never executes report or packet content",
+  "phase lab diagnostics do not settle claims",
+  "raw packet volume is diagnostic only"
+];
+var GRAPH_SAFETY = [
+  "raw packet volume is diagnostic only",
+  "candidate-only nodes do not improve positive phase components",
+  "graph construction does not execute packet content",
+  "graph construction does not settle claims"
+];
+function sha256Json(data) {
+  return createHash2("sha256").update(JSON.stringify(sortJson(data)), "utf8").digest("hex");
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function asRecords(value) {
+  return Array.isArray(value) ? value.filter((item) => Boolean(asRecord(item))) : [];
+}
+function stringList(value) {
+  if (value === void 0 || value === null) return [];
+  if (Array.isArray(value)) return value.map(String).sort();
+  if (value instanceof Set) return [...value].map(String).sort();
+  return [String(value)];
+}
+function numeric(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function numericDict(value) {
+  const record5 = asRecord(value);
+  if (!record5) return {};
+  return Object.fromEntries(
+    Object.entries(record5).map(([key, item]) => [key, numeric(item)]).sort(([a], [b]) => a.localeCompare(b))
+  );
+}
+function residualSummary(payload) {
+  const direct = asRecord(payload.residual_summary) ?? asRecord(payload.residual_ledger_summary);
+  if (direct) return numericDict(direct);
+  const coordinates = asRecord(asRecord(payload.residual_ledger)?.coordinates);
+  if (!coordinates) return {};
+  const summary = {};
+  for (const coordinate of Object.values(coordinates)) {
+    const item = asRecord(coordinate);
+    if (!item) continue;
+    const kind = String(item.kind ?? "residual");
+    summary[kind] = (summary[kind] ?? 0) + numeric(item.value);
+  }
+  return Object.fromEntries(
+    Object.entries(summary).sort(([a], [b]) => a.localeCompare(b))
+  );
+}
+function residualDebt(summary) {
+  return Object.values(summary).reduce((total, value) => total + value, 0);
+}
+function inferSchemaHint(payload) {
+  if ("packet_id" in payload && "content_digest" in payload && "content" in payload) {
+    return "PacketExchangeEnvelope";
+  }
+  if ("report_id" in payload && "registry" in payload)
+    return "RuntimeStepReport";
+  if ("graph_id" in payload && "nodes" in payload && "edges" in payload) {
+    return "EffectivePacketGraph";
+  }
+  if ("message_id" in payload) return "AgentMessageEnvelope";
+  if ("decision_id" in payload && "packet_id" in payload)
+    return "ALTAdmissionDecision";
+  if ("accepted" in payload && "workflow_usable" in payload)
+    return "AgentCheckReport";
+  return String(payload.schema_hint ?? payload.schema ?? "UnknownPICReport");
+}
+function inferSourceKind(payload, schemaHint) {
+  if (typeof payload.source_kind === "string") return payload.source_kind;
+  const mapping = {
+    AgentCheckReport: "agent-check",
+    AgentMessageEnvelope: "agent-message",
+    ALTAdmissionDecision: "alt-admission",
+    EffectivePacketGraph: "effective-graph",
+    PacketExchangeEnvelope: "packet-exchange",
+    RuntimeStepReport: "runtime-step-report"
+  };
+  return mapping[schemaHint] ?? "unknown-report";
+}
+function unsafeReasons(payload, missing, candidateOnlyReasons, settledBlockers) {
+  const text = JSON.stringify(payload).toLowerCase();
+  const reasons = [];
+  if ([
+    "npm install",
+    "npx",
+    "node ",
+    "docker run",
+    "kubectl",
+    "curl ",
+    "bash ",
+    "powershell",
+    "safe_commands"
+  ].some((marker) => text.includes(marker))) {
+    reasons.push("embedded command-like text remains inert");
+  }
+  if (missing.length > 0) reasons.push("missing obligations remain visible");
+  if (candidateOnlyReasons.length > 0)
+    reasons.push("candidate-only reasons remain visible");
+  if (settledBlockers.length > 0)
+    reasons.push("settlement blockers remain visible");
+  return dedupeSorted(reasons);
+}
+function eventFromPayload(payload, windowId, sequence, sourcePath, sourceKindOverride) {
+  const digest = sha256Json(payload);
+  const schemaHint = inferSchemaHint(payload);
+  const sourceKind = sourceKindOverride ?? inferSourceKind(payload, schemaHint);
+  const missing = dedupeSorted([
+    ...stringList(payload.missing_obligations),
+    ...stringList(payload.unresolved_obligations)
+  ]);
+  const candidateOnlyReasons = dedupeSorted(
+    stringList(payload.candidate_only_reasons)
+  );
+  const settledBlockers = dedupeSorted([
+    ...stringList(payload.settled_blockers),
+    ...payload.settled === true ? ["source-settled-ignored-by-phase-lab"] : []
+  ]);
+  const accepted = payload.accepted === true;
+  const candidateOnly = payload.candidate_only === true || candidateOnlyReasons.length > 0 || !accepted || [
+    "packet-exchange",
+    "general-intake",
+    "raw-external",
+    "phase-dashboard"
+  ].includes(sourceKind);
+  const reasons = unsafeReasons(
+    payload,
+    missing,
+    candidateOnlyReasons,
+    settledBlockers
+  );
+  const positiveContributionAllowed = accepted && !candidateOnly && reasons.length === 0 && missing.length === 0;
+  return {
+    accepted,
+    candidate_only: candidateOnly,
+    candidate_only_reasons: candidateOnlyReasons,
+    content_digest: digest,
+    event_id: `phase-lab-event:${sequence}:${digest.slice(0, 12)}`,
+    missing_obligations: missing,
+    operationally_usable: payload.operationally_usable === true,
+    payload,
+    positive_contribution_allowed: positiveContributionAllowed,
+    reasons: dedupeSorted([
+      "event content is stored as inert data",
+      ...reasons,
+      ...candidateOnly ? ["candidate-only event cannot improve phase metrics"] : []
+    ]),
+    residual_summary: residualSummary(payload),
+    safety_boundary: PHASE_LAB_SAFETY,
+    schema_hint: schemaHint,
+    settled: false,
+    settled_blockers: settledBlockers,
+    source_kind: sourceKind,
+    source_path: sourcePath ? basename2(sourcePath) : null,
+    window_id: windowId,
+    workflow_usable: payload.workflow_usable === true
+  };
+}
+function readJsonFile(path, label = "JSON") {
+  if (!path.toLowerCase().endsWith(".json")) {
+    throw new Error(
+      `${label} must be a JSON file; YAML input is not enabled in PIC-TS v0.5.0`
+    );
+  }
+  return parseJsonObject(readFileSync5(path, "utf8"), label);
+}
+function storePaths(storeDir) {
+  return {
+    events: join4(storeDir, "events.jsonl"),
+    manifest: join4(storeDir, "manifest.json"),
+    windows: join4(storeDir, "windows")
+  };
+}
+function windowFileName(windowId) {
+  return `${windowId.replace(/[^A-Za-z0-9_.-]/g, "_")}.json`;
+}
+function readEvents(storeDir) {
+  const eventsPath = storePaths(storeDir).events;
+  if (!existsSync4(eventsPath)) return [];
+  return readFileSync5(eventsPath, "utf8").split(/\r?\n/).filter(Boolean).map((line) => parseJsonObject(line, "phase lab event"));
+}
+function writeJson(path, data) {
+  writeFileSync2(path, stableStringify(data), "utf8");
+}
+function windowIndex(windowId, sequence, events) {
+  const residual = events.reduce(
+    (total, event) => total + residualDebt(numericDict(event.residual_summary)),
+    0
+  );
+  return {
+    accepted: true,
+    accepted_event_count: events.filter((event) => event.accepted === true).length,
+    candidate_only_event_count: events.filter(
+      (event) => event.candidate_only === true
+    ).length,
+    event_count: events.length,
+    event_ids: events.map((event) => String(event.event_id)),
+    missing_obligation_count: events.reduce(
+      (total, event) => total + stringList(event.missing_obligations).length,
+      0
+    ),
+    positive_contribution_event_count: events.filter(
+      (event) => event.positive_contribution_allowed === true
+    ).length,
+    reasons: ["window index preserves event residuals without settling claims"],
+    residual_debt: residual,
+    sequence,
+    settled: false,
+    settled_event_count: 0,
+    window_id: windowId
+  };
+}
+function readWindowIndexes(storeDir) {
+  const windowsDir = storePaths(storeDir).windows;
+  if (!existsSync4(windowsDir)) return [];
+  return readdirSync2(windowsDir).filter((name) => name !== "latest.json" && name.endsWith(".json")).sort().map(
+    (name) => parseJsonObject(readFileSync5(join4(windowsDir, name), "utf8"), "window")
+  );
+}
+function selectWindow(storeDir, selector = "latest") {
+  const windows = readWindowIndexes(storeDir);
+  if (windows.length === 0) throw new Error("phase lab store has no windows");
+  let selected;
+  if (selector === "latest" || selector === "all") {
+    selected = windows[windows.length - 1];
+  } else if (selector === "previous") {
+    selected = windows.length > 1 ? windows[windows.length - 2] : windows[windows.length - 1];
+  } else {
+    selected = windows.find((window) => window.window_id === selector);
+  }
+  if (!selected)
+    throw new Error(`unknown phase lab window ${JSON.stringify(selector)}`);
+  const selectedId = String(selected.window_id);
+  const events = selector === "all" ? readEvents(storeDir) : readEvents(storeDir).filter((event) => event.window_id === selectedId);
+  return { index: selected, events };
+}
+function writeManifest(storeDir) {
+  const paths = storePaths(storeDir);
+  mkdirSync2(paths.windows, { recursive: true });
+  const windows = readWindowIndexes(storeDir);
+  const events = readEvents(storeDir);
+  const manifest = {
+    accepted: true,
+    database_path: "events.jsonl",
+    event_count: events.length,
+    latest_window_id: windows.length > 0 ? String(windows[windows.length - 1]?.window_id ?? "") : null,
+    reasons: ["phase lab store is local and non-executing"],
+    safety_invariants: PHASE_LAB_SAFETY,
+    schema_version: "phase-lab-store-v1",
+    settled: false,
+    store_id: "phase-lab-store",
+    store_path: basename2(storeDir),
+    window_count: windows.length
+  };
+  writeJson(paths.manifest, manifest);
+  return manifest;
+}
+function initPhaseLabStore(outputDir) {
+  const paths = storePaths(outputDir);
+  mkdirSync2(paths.windows, { recursive: true });
+  if (!existsSync4(paths.events)) writeFileSync2(paths.events, "", "utf8");
+  return writeManifest(outputDir);
+}
+function ingestPayloads(storeDir, payloads) {
+  initPhaseLabStore(storeDir);
+  const sequence = readWindowIndexes(storeDir).length;
+  const offset = readEvents(storeDir).length;
+  const windowId = `phase-window:${String(sequence).padStart(4, "0")}`;
+  const events = payloads.map(
+    (item, index2) => eventFromPayload(
+      item.payload,
+      windowId,
+      offset + index2,
+      item.path,
+      item.sourceKind
+    )
+  );
+  const index = windowIndex(windowId, sequence, events);
+  const paths = storePaths(storeDir);
+  const append = events.map((event) => JSON.stringify(sortJson(event))).join("\n");
+  if (append) {
+    writeFileSync2(paths.events, `${append}
+`, { encoding: "utf8", flag: "a" });
+  }
+  writeJson(join4(paths.windows, windowFileName(windowId)), index);
+  writeJson(join4(paths.windows, "latest.json"), index);
+  const manifest = writeManifest(storeDir);
+  return {
+    accepted: events.length > 0,
+    content_treated_as_data: true,
+    executed_command_count: 0,
+    ingested_events: events,
+    reasons: [
+      "ingested files were stored as inert local data",
+      "no embedded command, safe_command, network, repository, or model action was executed"
+    ],
+    rejected_paths: [],
+    report_id: `phase-lab-ingest:${windowId}`,
+    settled: false,
+    store_manifest: manifest,
+    window: index,
+    workflow_usable: true
+  };
+}
+function ingestPhaseLabReport(storeDir, reportPath) {
+  return ingestPayloads(storeDir, [
+    { payload: readJsonFile(reportPath, "phase lab report"), path: reportPath }
+  ]);
+}
+function ingestPhaseLabPacket(storeDir, packetPath) {
+  return ingestPayloads(storeDir, [
+    {
+      payload: readJsonFile(packetPath, "phase lab packet"),
+      path: packetPath,
+      sourceKind: "packet-exchange"
+    }
+  ]);
+}
+function listPhaseLabWindows(storeDir) {
+  return {
+    settled: false,
+    store_manifest: writeManifest(storeDir),
+    windows: readWindowIndexes(storeDir)
+  };
+}
+function eligibilityBlockers(event) {
+  const joined = [
+    event.source_kind,
+    ...stringList(event.missing_obligations),
+    ...stringList(event.candidate_only_reasons),
+    ...stringList(event.settled_blockers),
+    ...stringList(event.reasons)
+  ].join(" ").toLowerCase();
+  const blockers = [];
+  const markers = {
+    "authority-invalid": [
+      "authority-invalid",
+      "missing authority",
+      "authority"
+    ],
+    "candidate-only": ["candidate-only"],
+    "hash-invalid": ["hash-invalid", "digest mismatch"],
+    "raw-external-volume": ["general-intake", "raw-external"],
+    "rollback-missing": ["rollback", "safe abort"],
+    "salience-obstruction": ["salience", "queue occupation"],
+    stale: ["stale", "expired"],
+    "verification-blocked": [
+      "missing evidence",
+      "missing verifier",
+      "verification"
+    ]
+  };
+  for (const [blocker, needles] of Object.entries(markers)) {
+    if (needles.some((needle) => joined.includes(needle)))
+      blockers.push(blocker);
+  }
+  if (event.candidate_only === true) blockers.push("candidate-only");
+  return dedupeSorted(blockers);
+}
+function nodeFromEvent(event) {
+  const blockers = eligibilityBlockers(event);
+  const eligible = event.positive_contribution_allowed === true && blockers.length === 0;
+  const status = eligible ? "accepted" : event.candidate_only === true ? "candidate-only" : "diagnostic";
+  return {
+    accepted: event.accepted === true,
+    content_digest: String(event.content_digest ?? ""),
+    contribution: {
+      candidate_only: !eligible,
+      non_contributing_reason: eligible ? "" : "eligibility blockers prevent positive contribution",
+      positive_contribution: eligible,
+      settled: false,
+      status
+    },
+    eligibility: {
+      accepted_or_certificate_admissible: event.accepted === true,
+      agent_text_not_treated_as_evidence: event.source_kind !== "agent-text-only",
+      authority_valid: !blockers.includes("authority-invalid"),
+      blockers,
+      eligible,
+      hash_valid: !blockers.includes("hash-invalid"),
+      not_raw_external_volume: !blockers.includes("raw-external-volume"),
+      not_registry_metadata_only: event.source_kind !== "registry-metadata",
+      not_salience_blocked: !blockers.includes("salience-obstruction"),
+      not_stale: !blockers.includes("stale"),
+      not_verification_blocked: !blockers.includes("verification-blocked"),
+      residuals_preserved: true,
+      retrievable: Boolean(event.content_digest),
+      rollback_available_or_not_required: !blockers.includes("rollback-missing"),
+      within_validity_domain: true
+    },
+    missing_obligations: stringList(event.missing_obligations),
+    node_id: `node:${String(event.content_digest ?? "").slice(0, 12)}`,
+    operationally_usable: event.operationally_usable === true,
+    reasons: stringList(event.reasons),
+    residual_summary: numericDict(event.residual_summary),
+    schema_hint: String(event.schema_hint ?? "UnknownPICReport"),
+    settled: false,
+    source_event_id: String(event.event_id ?? ""),
+    source_kind: String(event.source_kind ?? "unknown-report"),
+    workflow_usable: event.workflow_usable === true
+  };
+}
+function extractEdges(payload) {
+  const edges = [];
+  for (const key of ["edges", "edge_witnesses", "edge_certificates"]) {
+    edges.push(...asRecords(payload[key]));
+  }
+  const registry = asRecord(payload.registry);
+  if (registry) edges.push(...extractEdges(registry));
+  const content = asRecord(payload.content);
+  if (content) edges.push(...extractEdges(content));
+  return edges;
+}
+function nodeIdForRef(ref, nodes) {
+  if (!ref) return void 0;
+  return nodes.map((node) => String(node.node_id)).find((nodeId) => {
+    const node = nodes.find((item) => item.node_id === nodeId);
+    return node && [
+      node.node_id,
+      node.content_digest,
+      String(node.content_digest).slice(0, 12),
+      node.source_event_id
+    ].map(String).includes(ref);
+  });
+}
+function nodePositive(nodeId, nodes) {
+  const node = nodes.find((item) => item.node_id === nodeId);
+  return asRecord(node?.contribution)?.positive_contribution === true;
+}
+function edgesFromEvents(nodes, events) {
+  const edges = [];
+  events.forEach((event, eventIndex) => {
+    const node = nodes[eventIndex];
+    if (!node) return;
+    extractEdges(asRecord(event.payload) ?? {}).forEach((edge, index) => {
+      const sourceIds = stringList(edge.source_packet_ids).map((ref) => nodeIdForRef(ref, nodes)).filter((item) => Boolean(item));
+      const target = nodeIdForRef(String(edge.target_packet_id ?? ""), nodes) ?? String(node.node_id);
+      const evidenceRefs = stringList(edge.evidence_refs);
+      const accepted = edge.accepted === true || event.accepted === true;
+      const evidenceSupported = accepted && evidenceRefs.length > 0;
+      const positive = evidenceSupported && sourceIds.every((source) => nodePositive(source, nodes)) && nodePositive(target, nodes);
+      const edgeId = String(
+        edge.edge_id ?? `edge:${String(node.node_id)}:${index}`
+      );
+      edges.push({
+        accepted,
+        contribution: {
+          candidate_only: !positive,
+          non_contributing_reason: positive ? "" : "edge lacks accepted evidence support",
+          positive_contribution: positive,
+          settled: false,
+          status: positive ? "accepted" : "diagnostic"
+        },
+        edge_id: edgeId,
+        evidence: {
+          edge_certificate_refs: stringList(edge.edge_certificate_refs),
+          evidence_refs: evidenceRefs,
+          evidence_supported: evidenceSupported,
+          missing_evidence: evidenceSupported ? [] : ["edge evidence refs required"],
+          verifier_resolution_refs: stringList(edge.verifier_resolution_refs)
+        },
+        reasons: ["edge extracted from inert report data"],
+        relation_type: String(
+          edge.edge_type ?? edge.relation_type ?? "semantic-dependency"
+        ),
+        residual_summary: numericDict(event.residual_summary),
+        settled: false,
+        source_node_ids: sourceIds.length > 0 ? sourceIds : [String(node.node_id)],
+        target_node_id: target
+      });
+    });
+  });
+  return edges;
+}
+function buildEffectivePacketGraph(input) {
+  const events = Array.isArray(input) ? input : Array.isArray(input.events) ? input.events : [];
+  const graphId = Array.isArray(input) ? "effective-packet-graph" : String(input.graph_id ?? "effective-packet-graph");
+  const sourceWindowId = Array.isArray(input) ? "adhoc" : String(input.source_window_id ?? "adhoc");
+  const normalized = events.map(
+    (event, index) => event.event_id ? event : eventFromPayload(event, sourceWindowId, index, void 0, void 0)
+  );
+  const nodes = normalized.map(nodeFromEvent);
+  const edges = edgesFromEvents(nodes, normalized);
+  const nodeCountByStatus = {};
+  for (const node of nodes) {
+    const status = String(asRecord(node.contribution)?.status ?? "diagnostic");
+    nodeCountByStatus[status] = (nodeCountByStatus[status] ?? 0) + 1;
+  }
+  const edgeCountByRelation = {};
+  for (const edge of edges) {
+    const relation = String(edge.relation_type ?? "semantic-dependency");
+    edgeCountByRelation[relation] = (edgeCountByRelation[relation] ?? 0) + 1;
+  }
+  const mergedResidual = {};
+  for (const node of nodes) {
+    for (const [key, value] of Object.entries(
+      numericDict(node.residual_summary)
+    )) {
+      mergedResidual[key] = (mergedResidual[key] ?? 0) + value;
+    }
+  }
+  const acceptedPacketCapital = nodes.filter(
+    (node) => asRecord(node.contribution)?.positive_contribution === true
+  ).length;
+  return {
+    accepted: nodes.length > 0,
+    accepted_packet_capital: acceptedPacketCapital,
+    candidate_only_packets: nodes.filter(
+      (node) => asRecord(node.contribution)?.candidate_only === true
+    ).length,
+    edge_count_by_relation: Object.fromEntries(
+      Object.entries(edgeCountByRelation).sort()
+    ),
+    edges,
+    graph_id: graphId,
+    graph_safety_boundary: GRAPH_SAFETY,
+    missing_edge_evidence: edges.filter(
+      (edge) => edge.accepted === true && asRecord(edge.evidence)?.evidence_supported !== true
+    ).map((edge) => String(edge.edge_id)),
+    node_count_by_status: Object.fromEntries(
+      Object.entries(nodeCountByStatus).sort()
+    ),
+    nodes,
+    non_contributing_volume: nodes.filter(
+      (node) => asRecord(node.contribution)?.positive_contribution !== true
+    ).length,
+    operationally_usable: acceptedPacketCapital > 0,
+    reasons: [
+      "effective graph separates positive contribution from diagnostic volume",
+      "raw packet count does not increase positive phase metrics"
+    ],
+    rejected_or_quarantined_packets: nodes.filter(
+      (node) => ["rejected", "quarantined"].includes(
+        String(asRecord(node.contribution)?.status ?? "")
+      )
+    ).length,
+    residual_summary: {
+      candidate_only_reasons: dedupeSorted(
+        normalized.flatMap((event) => stringList(event.candidate_only_reasons))
+      ),
+      missing_obligation_count: nodes.reduce(
+        (total, node) => total + stringList(node.missing_obligations).length,
+        0
+      ),
+      residual_debt: residualDebt(mergedResidual),
+      residual_summary: Object.fromEntries(
+        Object.entries(mergedResidual).sort()
+      ),
+      settled_blockers: dedupeSorted(
+        normalized.flatMap((event) => [
+          ...stringList(event.settled_blockers),
+          ...stringList(event.missing_obligations)
+        ])
+      )
+    },
+    semantic_edge_witnesses: edges.map((edge) => asRecord(edge.evidence)).filter(
+      (evidence) => Boolean(evidence?.evidence_supported)
+    ),
+    settled: false,
+    source_window_id: sourceWindowId,
+    stale_or_unsafe_packets: nodes.filter(
+      (node) => stringList(asRecord(node.eligibility)?.blockers).length > 0
+    ).map((node) => String(node.node_id)),
+    workflow_usable: true
+  };
+}
+function positiveEdges(graph) {
+  return asRecords(graph.edges).filter(
+    (edge) => asRecord(edge.contribution)?.positive_contribution === true && asRecord(edge.evidence)?.evidence_supported === true
+  );
+}
+function observePhaseWindow(window, events, graph) {
+  const effectiveNodeCount = numeric(graph.accepted_packet_capital);
+  const effectiveEdgeCount = positiveEdges(graph).length;
+  const executionAvailablePathCount = detectExecutionAvailablePaths(graph).accepted_path_count;
+  const closureWitnessCount = asRecords(
+    detectAutocatalyticClosure(graph).closure_witnesses
+  ).length;
+  const total = Math.max(1, events.length);
+  const acceptedPacketCount = events.filter(
+    (event) => event.accepted === true
+  ).length;
+  const missingObligationCount = events.reduce(
+    (sum, event) => sum + stringList(event.missing_obligations).length,
+    0
+  );
+  const residual = numeric(asRecord(graph.residual_summary)?.residual_debt);
+  const candidateOnlyCount = events.filter(
+    (event) => event.candidate_only === true
+  ).length;
+  const observation = {
+    accepted: events.length > 0,
+    accepted_packet_count: acceptedPacketCount,
+    alt_certified_capital_count: events.filter(
+      (event) => String(event.source_kind).includes("alt") && event.positive_contribution_allowed === true
+    ).length,
+    alt_liquidity_candidate_count: events.filter(
+      (event) => String(event.source_kind).includes("alt")
+    ).length,
+    autocatalytic_closure_score: effectiveNodeCount > 0 ? closureWitnessCount / effectiveNodeCount : 0,
+    basin_reachability_proxy: {
+      effective_node_count: effectiveNodeCount,
+      execution_available_path_count: executionAvailablePathCount,
+      reachability_proxy: executionAvailablePathCount / Math.max(1, effectiveNodeCount)
+    },
+    bottleneck_count_by_type: Object.fromEntries(
+      asRecords(graph.nodes).flatMap((node) => stringList(asRecord(node.eligibility)?.blockers)).reduce((map, blocker) => {
+        map.set(blocker, (map.get(blocker) ?? 0) + 1);
+        return map;
+      }, /* @__PURE__ */ new Map()).entries()
+    ),
+    candidate_only_packet_count: candidateOnlyCount,
+    closure_witness_count: closureWitnessCount,
+    components: [
+      {
+        component: "accepted_packet_count",
+        diagnostic_only: false,
+        distance: 0,
+        positive_contribution_source: "effective-graph-only",
+        threshold: 0,
+        value: acceptedPacketCount
+      },
+      {
+        component: "raw_volume",
+        diagnostic_only: true,
+        distance: 0,
+        positive_contribution_source: "diagnostic-only",
+        threshold: 0,
+        value: events.length
+      }
+    ],
+    effective_edge_count: effectiveEdgeCount,
+    effective_node_count: effectiveNodeCount,
+    execution_available_path_count: executionAvailablePathCount,
+    false_liquidity_load: {
+      candidate_count: candidateOnlyCount,
+      certified_count: 0,
+      load: candidateOnlyCount / total
+    },
+    missing_obligation_count: missingObligationCount,
+    observation_id: "phase-window-observation",
+    operationally_usable: effectiveNodeCount > 0,
+    oracle_truth_proven: false,
+    packet_candidate_count: events.length,
+    phase_gap_vector: {
+      closure: Math.max(0, 1 - closureWitnessCount),
+      effective_edges: Math.max(0, 1 - effectiveEdgeCount),
+      effective_nodes: Math.max(0, 1 - effectiveNodeCount),
+      execution_paths: Math.max(0, 1 - executionAvailablePathCount)
+    },
+    physical_truth_proven: false,
+    proves_physical_or_oracle_truth: false,
+    proves_real_asi: false,
+    protocol_relative: true,
+    protocol_relative_only: true,
+    raw_external_volume_diagnostic_only: true,
+    real_asi_proof: false,
+    reasons: [
+      "window observation is protocol-relative only",
+      "raw external volume is diagnostic only"
+    ],
+    residual_debt: residual,
+    salience_obstruction_load: {
+      blocked_count: candidateOnlyCount,
+      load: candidateOnlyCount / total,
+      total_count: events.length
+    },
+    settled: false,
+    settled_packet_count: 0,
+    threshold_distance: Math.max(0, 1 - effectiveNodeCount) + Math.max(0, 1 - effectiveEdgeCount) + Math.max(0, 1 - closureWitnessCount) + Math.max(0, 1 - executionAvailablePathCount),
+    verification_backlog: missingObligationCount,
+    verification_throughput: {
+      accepted_count: acceptedPacketCount,
+      backlog_count: missingObligationCount,
+      throughput_ratio: acceptedPacketCount / total
+    },
+    waste_load: {
+      load: numeric(graph.non_contributing_volume) / total,
+      non_contributing_volume: numeric(graph.non_contributing_volume),
+      total_volume: events.length
+    },
+    window: {
+      event_count: numeric(window.event_count),
+      event_ids: stringList(window.event_ids),
+      sequence: numeric(window.sequence),
+      window_id: String(window.window_id ?? "phase-window")
+    },
+    workflow_usable: true,
+    workflow_usable_packet_count: events.filter(
+      (event) => event.workflow_usable === true
+    ).length
+  };
+  return observation;
+}
+function comparePhaseWindows(baseline, candidate) {
+  const metricDelta = {
+    closure_witness_count: numeric(candidate.closure_witness_count) - numeric(baseline.closure_witness_count),
+    effective_edge_count: numeric(candidate.effective_edge_count) - numeric(baseline.effective_edge_count),
+    effective_node_count: numeric(candidate.effective_node_count) - numeric(baseline.effective_node_count),
+    execution_available_path_count: numeric(candidate.execution_available_path_count) - numeric(baseline.execution_available_path_count),
+    residual_debt: numeric(candidate.residual_debt) - numeric(baseline.residual_debt)
+  };
+  return {
+    accepted: true,
+    baseline_window_id: String(asRecord(baseline.window)?.window_id ?? ""),
+    candidate_window_id: String(asRecord(candidate.window)?.window_id ?? ""),
+    comparison_id: "phase-window-comparison",
+    diagnostic_only_components: ["packet_candidate_count", "raw_volume"],
+    metric_delta: metricDelta,
+    positive_progress_components: Object.entries(metricDelta).filter(([key, value]) => key !== "residual_debt" && value > 0).map(([key]) => key),
+    reasons: ["comparison preserves protocol-relative diagnostic status"],
+    settled: false,
+    workflow_usable: true
+  };
+}
+function detectAutocatalyticClosure(graph) {
+  const closureWitnesses = [];
+  const defects = [];
+  for (const edge of positiveEdges(graph)) {
+    const sources = stringList(edge.source_node_ids);
+    const target = String(edge.target_node_id ?? "");
+    if (sources.includes(target)) {
+      const witnessId = `closure-witness:${String(edge.edge_id)}`;
+      closureWitnesses.push({
+        accepted: true,
+        edge_ids: [String(edge.edge_id)],
+        evidence_supported: true,
+        execution_available: false,
+        packet_ids: dedupeSorted([...sources, target]),
+        productive: true,
+        protocol_relative_only: true,
+        reasons: [
+          "witness is evidence-supported within the effective graph",
+          "witness remains diagnostic until finite threshold checks pass"
+        ],
+        settled: false,
+        witness_id: witnessId,
+        witness_kind: "autocatalytic-closure"
+      });
+    }
+  }
+  for (const edge of asRecords(graph.edges)) {
+    if (edge.accepted === true && asRecord(edge.evidence)?.evidence_supported !== true) {
+      defects.push({
+        defect_id: `closure-defect:${String(edge.edge_id)}`,
+        defect_type: "missing-edge-evidence",
+        packet_or_edge_id: String(edge.edge_id),
+        residual_preserved: true
+      });
+    }
+  }
+  const status = closureWitnesses.length > 0 && defects.length === 0 ? "candidate" : "abstain";
+  return {
+    accepted: status === "candidate",
+    certificate_candidate: {
+      abstention_reasons: closureWitnesses.length > 0 ? [] : [
+        {
+          missing_evidence_refs: [],
+          reason: "closure requires evidence-supported accepted edges",
+          reason_id: "closure-abstain:no-evidence-supported-cycle"
+        }
+      ],
+      accepted: status === "candidate",
+      certificate_id: "closure-certificate-candidate",
+      certificate_status: status,
+      defects,
+      reasons: [
+        "closure candidate is not automatically settled",
+        "candidate-only cycles do not count"
+      ],
+      settled: false,
+      witness_ids: closureWitnesses.map(
+        (witness) => String(witness.witness_id)
+      )
+    },
+    closure_score: closureWitnesses.length / Math.max(1, asRecords(graph.nodes).length),
+    closure_witnesses: closureWitnesses,
+    defects,
+    executable_witnesses: [],
+    graph_id: String(graph.graph_id ?? "effective-packet-graph"),
+    operationally_usable: status === "candidate",
+    productive_witnesses: closureWitnesses.map((witness) => ({
+      accepted: true,
+      packet_ids: witness.packet_ids,
+      productive_edge_ids: witness.edge_ids,
+      productivity_lower_bound: 0.1,
+      reasons: [
+        "self-supporting evidence edge is productive in declared scope"
+      ],
+      settled: false,
+      witness_id: `productive:${String(witness.witness_id)}`
+    })),
+    reasons: ["closure detection does not execute or settle paths"],
+    report_id: "autocatalytic-closure-report",
+    settled: false,
+    support_hyperpaths: [],
+    workflow_usable: true
+  };
+}
+function detectExecutionAvailablePaths(graph) {
+  const paths = positiveEdges(graph).map((edge) => {
+    const pathId = `execution-path:${String(edge.edge_id)}`;
+    const reasons = [
+      "execution authority is not granted by PIC-TS",
+      "receiver context and action boundary remain diagnostic"
+    ];
+    return {
+      accepted: false,
+      action_boundary_requirements: [
+        {
+          requirement_id: `${pathId}:authority`,
+          requirement_type: "explicit-scope-bounded-authority",
+          residual: "host runtime authority required",
+          satisfied: false
+        }
+      ],
+      authority_status: {
+        authority_status: "not-granted",
+        explicit_scope_bounded: false,
+        grants_execution: false,
+        reasons
+      },
+      blocked: true,
+      candidate_only: true,
+      edge_ids: [String(edge.edge_id)],
+      not_executed: true,
+      packet_ids: dedupeSorted([
+        ...stringList(edge.source_node_ids),
+        String(edge.target_node_id ?? "")
+      ]),
+      path_id: pathId,
+      reasons,
+      receiver_context: {
+        evidence_refs: [],
+        present: false,
+        receiver_context_id: "receiver-context:missing"
+      },
+      settled: false,
+      witness: {
+        accepted: false,
+        edge_ids: [String(edge.edge_id)],
+        packet_ids: dedupeSorted([
+          ...stringList(edge.source_node_ids),
+          String(edge.target_node_id ?? "")
+        ]),
+        reasons,
+        settled: false,
+        witness_id: `execution-witness:${String(edge.edge_id)}`
+      }
+    };
+  });
+  return {
+    accepted: paths.length > 0,
+    accepted_path_count: 0,
+    authority_requirements: ["explicit-scope-bounded-authority"],
+    blocked_path_count: paths.length,
+    blocker_reason_by_path: Object.fromEntries(
+      paths.map((path) => [String(path.path_id), stringList(path.reasons)])
+    ),
+    candidate_only_path_count: paths.length,
+    executed_path_count: 0,
+    execution_authority_granted: false,
+    graph_id: String(graph.graph_id ?? "effective-packet-graph"),
+    operationally_usable: false,
+    path_count: paths.length,
+    path_density: 0,
+    paths,
+    reasons: ["execution-available path detection never executes paths"],
+    report_id: "execution-available-path-density",
+    residual_carry_forward: stringList(
+      asRecord(graph.residual_summary)?.settled_blockers
+    ),
+    rollback_requirements: ["rollback-or-safe-abort"],
+    settled: false,
+    workflow_usable: true
+  };
+}
+function buildPhaseThresholdStatus(observation, threshold) {
+  const pathDensity = numeric(
+    asRecord(observation.basin_reachability_proxy)?.reachability_proxy
+  );
+  const checks = {
+    maximum_false_liquidity_load: numeric(asRecord(observation.false_liquidity_load)?.load) <= numeric(threshold.maximum_false_liquidity_load ?? 0.5),
+    maximum_residual_debt: numeric(observation.residual_debt) <= numeric(threshold.maximum_residual_debt ?? 0),
+    maximum_salience_obstruction: numeric(asRecord(observation.salience_obstruction_load)?.load) <= numeric(threshold.maximum_salience_obstruction ?? 0.5),
+    minimum_accepted_packet_count: numeric(observation.accepted_packet_count) >= numeric(threshold.minimum_accepted_packet_count ?? 1),
+    minimum_alt_to_ecpt_lift_count: numeric(observation.alt_certified_capital_count) >= numeric(threshold.minimum_alt_to_ecpt_lift_count ?? 0),
+    minimum_closure_witness_count: numeric(observation.closure_witness_count) >= numeric(threshold.minimum_closure_witness_count ?? 1),
+    minimum_effective_edge_count: numeric(observation.effective_edge_count) >= numeric(threshold.minimum_effective_edge_count ?? 1),
+    minimum_execution_available_path_density: pathDensity >= numeric(threshold.minimum_execution_available_path_density ?? 0.1),
+    minimum_verification_throughput: numeric(
+      asRecord(observation.verification_throughput)?.throughput_ratio
+    ) >= numeric(threshold.minimum_verification_throughput ?? 0.1)
+  };
+  const failed = Object.entries(checks).filter(([, passed]) => !passed).map(([key]) => key).sort();
+  const status = failed.length === 0 ? "candidate" : "abstain";
+  return {
+    accepted: status === "candidate",
+    abstention_reasons: failed.map(
+      (component) => `missing finite threshold component: ${component}`
+    ),
+    certificate_status: status,
+    component_status: Object.fromEntries(Object.entries(checks).sort()),
+    failed_components: failed,
+    oracle_truth_proven: false,
+    physical_truth_proven: false,
+    protocol_relative: true,
+    protocol_relative_only: true,
+    real_asi_proof: false,
+    reasons: [
+      "threshold status is protocol-relative only",
+      "threshold status does not prove real ASI"
+    ],
+    rejection_reasons: [],
+    settled: false,
+    status_id: "asi-proxy-threshold-status",
+    threshold,
+    threshold_distance: failed.length,
+    observation
+  };
+}
+function buildCollectivePhaseCertificateCandidate(thresholdStatus, graph) {
+  const status = String(thresholdStatus.certificate_status ?? "abstain");
+  const defects = stringList(thresholdStatus.failed_components).map(
+    (component) => ({
+      component,
+      defect_id: `phase-defect:${component}`,
+      defect_type: "threshold-component-missing",
+      required_remediation: `provide finite evidence for ${component}`,
+      residual_preserved: true
+    })
+  );
+  return {
+    accepted: status === "candidate",
+    abstention_report: status === "candidate" ? null : {
+      defects,
+      protocol_relative_only: true,
+      reasons: ["certificate abstains when finite evidence is missing"],
+      report_id: "collective-phase-abstention",
+      settled: false,
+      threshold_status: thresholdStatus
+    },
+    certificate_id: "collective-phase-certificate-candidate",
+    certificate_status: status,
+    defects,
+    execution_authority_granted: false,
+    finite_requirements_passed: status === "candidate",
+    graph_id: String(graph.graph_id ?? ""),
+    observation_id: String(
+      asRecord(thresholdStatus.observation)?.observation_id ?? ""
+    ),
+    operationally_usable: status === "candidate",
+    oracle_truth_proven: false,
+    physical_truth_proven: false,
+    protocol_relative_only: true,
+    proves_physical_or_oracle_truth: false,
+    proves_real_asi: false,
+    reasons: [
+      "certificate candidate is protocol-relative only",
+      "certificate candidate does not prove real ASI",
+      "certificate candidate does not settle diagnostic reports"
+    ],
+    settled: false,
+    threshold_status: thresholdStatus,
+    workflow_usable: true
+  };
+}
+function loadPhaseLabObservation(storeDir, window = "latest") {
+  const selected = selectWindow(storeDir, window);
+  const graph = buildEffectivePacketGraph({
+    events: selected.events,
+    graph_id: `effective-graph:${String(selected.index.window_id ?? "window")}`,
+    source_window_id: String(selected.index.window_id ?? "window")
+  });
+  return {
+    observation: observePhaseWindow(selected.index, selected.events, graph),
+    graph
+  };
+}
+function loadPhaseLabGraph(storeDir, window = "all") {
+  const selected = selectWindow(storeDir, window);
+  return buildEffectivePacketGraph({
+    events: selected.events,
+    graph_id: `effective-graph:${String(selected.index.window_id ?? "window")}`,
+    source_window_id: String(selected.index.window_id ?? "window")
+  });
+}
+function exportPhaseLabStore(storeDir, outputDir) {
+  mkdirSync2(outputDir, { recursive: true });
+  const manifest = writeManifest(storeDir);
+  const events = readEvents(storeDir);
+  const graph = buildEffectivePacketGraph({
+    events,
+    graph_id: "phase-lab-export-effective-graph",
+    source_window_id: String(manifest.latest_window_id ?? "adhoc")
+  });
+  const files = [];
+  const write = (name, data) => {
+    writeJson(join4(outputDir, name), data);
+    files.push(name);
+  };
+  write("manifest.json", manifest);
+  write("events.json", {
+    absolute_paths_sanitized: true,
+    events,
+    settled: false
+  });
+  write("effective_graph.json", graph);
+  write("windows.json", {
+    settled: false,
+    windows: readWindowIndexes(storeDir)
+  });
+  if (events.length > 0) {
+    const { observation } = loadPhaseLabObservation(storeDir, "latest");
+    write("phase_window_observation.json", observation);
+  }
+  return {
+    accepted: true,
+    absolute_paths_sanitized: true,
+    export_id: "phase-lab-export",
+    files: files.sort(),
+    output_dir: basename2(outputDir),
+    reasons: ["phase lab export sanitizes local paths and preserves residuals"],
+    settled: false,
+    store_manifest: manifest
+  };
+}
+
+// src/bit_engine/index.ts
+var BOTTLENECK_CLASSES = [
+  "missing_evidence",
+  "missing_verifier_route",
+  "missing_semantic_edge",
+  "missing_rollback_support",
+  "missing_authority",
+  "missing_receiver_context",
+  "identity_sybil_blocker",
+  "stale_packet",
+  "false_liquidity_blocker",
+  "salience_obstruction",
+  "queue_occupation",
+  "missing_alt_lift",
+  "trace_boundary_mismatch",
+  "external_domain_obligation"
+];
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function records(value) {
+  return Array.isArray(value) ? value.filter((item) => Boolean(record(item))) : [];
+}
+function strings(value) {
+  if (Array.isArray(value)) return value.map(String).sort();
+  if (value === void 0 || value === null) return [];
+  return [String(value)];
+}
+function classForBlocker(blocker) {
+  const normalized = blocker.replaceAll("-", "_");
+  if (BOTTLENECK_CLASSES.includes(normalized)) return normalized;
+  if (normalized.includes("evidence")) return "missing_evidence";
+  if (normalized.includes("verification")) return "missing_verifier_route";
+  if (normalized.includes("edge")) return "missing_semantic_edge";
+  if (normalized.includes("rollback")) return "missing_rollback_support";
+  if (normalized.includes("authority")) return "missing_authority";
+  if (normalized.includes("receiver")) return "missing_receiver_context";
+  if (normalized.includes("stale")) return "stale_packet";
+  if (normalized.includes("salience")) return "salience_obstruction";
+  if (normalized.includes("external")) return "external_domain_obligation";
+  return "external_domain_obligation";
+}
+function minimalConditions(bottleneckId, bottleneckClass) {
+  return [
+    {
+      condition_id: `mec:${bottleneckId}:evidence`,
+      condition_kind: "finite-evidence",
+      description: `provide finite evidence for ${bottleneckClass}`,
+      execution_authority_granted: false,
+      settled: false
+    },
+    {
+      condition_id: `mec:${bottleneckId}:audit`,
+      condition_kind: "post-check-audit",
+      description: "preserve residuals and rerun the relevant checker",
+      execution_authority_granted: false,
+      settled: false
+    }
+  ];
+}
+function diagnoseBottlenecks(graph) {
+  const diagnoses = [];
+  for (const node of records(graph.nodes)) {
+    for (const blocker of strings(record(node.eligibility)?.blockers)) {
+      const bottleneckClass = classForBlocker(blocker);
+      const bottleneckId = `bottleneck:${String(node.node_id)}:${bottleneckClass}`;
+      diagnoses.push({
+        accepted: true,
+        bottleneck_class: bottleneckClass,
+        bottleneck_id: bottleneckId,
+        capability_expression_paths: [
+          {
+            accepted: false,
+            path_id: `capability-path:${String(node.node_id)}`,
+            reasons: [`blocked by ${blocker}`],
+            settled: false
+          }
+        ],
+        minimal_enabling_conditions: minimalConditions(
+          bottleneckId,
+          bottleneckClass
+        ),
+        node_id: String(node.node_id ?? ""),
+        reasons: [`effective graph node is blocked by ${blocker}`],
+        settled: false
+      });
+    }
+  }
+  for (const edgeId of strings(graph.missing_edge_evidence)) {
+    const bottleneckId = `bottleneck:${edgeId}:missing_semantic_edge`;
+    diagnoses.push({
+      accepted: true,
+      bottleneck_class: "missing_semantic_edge",
+      bottleneck_id: bottleneckId,
+      edge_id: edgeId,
+      minimal_enabling_conditions: minimalConditions(
+        bottleneckId,
+        "missing_semantic_edge"
+      ),
+      reasons: ["edge lacks semantic evidence"],
+      settled: false
+    });
+  }
+  return {
+    accepted: true,
+    bottleneck_count: diagnoses.length,
+    bottlenecks: diagnoses.sort(
+      (a, b) => String(a.bottleneck_id).localeCompare(String(b.bottleneck_id))
+    ),
+    execution_authority_granted: false,
+    graph_id: String(graph.graph_id ?? ""),
+    report_id: "bottleneck-inversion-report",
+    settled: false,
+    workflow_usable: true
+  };
+}
+function buildMinimalEnablingConditions(bottleneckId, report) {
+  const found = records(report?.bottlenecks).find(
+    (item) => item.bottleneck_id === bottleneckId
+  );
+  if (found) return records(found.minimal_enabling_conditions);
+  return minimalConditions(bottleneckId, "external_domain_obligation");
+}
+function invertBottlenecks(report) {
+  const candidates = records(report.bottlenecks).map((bottleneck, index) => {
+    const bottleneckId = String(
+      bottleneck.bottleneck_id ?? `bottleneck:${index}`
+    );
+    const bottleneckClass = String(
+      bottleneck.bottleneck_class ?? "external_domain_obligation"
+    );
+    return {
+      accepted: true,
+      bottleneck_class: bottleneckClass,
+      bottleneck_id: bottleneckId,
+      candidate_id: `inversion-candidate:${bottleneckId}`,
+      expected_activation_gain: {
+        gain_lower_bound: bottleneckClass === "missing_semantic_edge" ? 0.2 : 0.1,
+        protocol_relative_only: true
+      },
+      execution_authority_granted: false,
+      minimal_enabling_conditions: buildMinimalEnablingConditions(
+        bottleneckId,
+        report
+      ),
+      post_inversion_audit_plan: {
+        audit_steps: ["rerun graph", "rerun observation", "preserve residuals"],
+        settled: false
+      },
+      reasons: ["inversion candidate is recommendation-only"],
+      risk_hazard_authority_notes: [
+        "host runtime authority required before external effects"
+      ],
+      rollback_or_deactivation_plan: {
+        plan_id: `rollback:${bottleneckId}`,
+        required: true,
+        settled: false
+      },
+      settled: false,
+      verification_cost: 1,
+      why_not_settled: "minimal enabling conditions are not discharged"
+    };
+  });
+  return {
+    accepted: true,
+    candidate_count: candidates.length,
+    candidates,
+    execution_authority_granted: false,
+    report_id: "bottleneck-inversion-candidates",
+    settled: false,
+    workflow_usable: true
+  };
+}
+function buildInversionCertificate(candidate) {
+  const selected = records(candidate.inversion_candidates)[0] ?? records(candidate.candidates)[0] ?? candidate;
+  return {
+    accepted: selected.accepted === true,
+    candidate: selected,
+    certificate_id: `inversion-certificate:${String(selected.candidate_id ?? "candidate")}`,
+    certificate_status: "candidate",
+    execution_authority_granted: false,
+    finite_requirements_passed: false,
+    reasons: [
+      "inversion certificate is a candidate only",
+      "post-inversion audit remains required"
+    ],
+    settled: false,
+    workflow_usable: true
+  };
+}
+function compareBottleneckBaseline(baseline, candidate) {
+  const delta = {
+    closure_witness_count: Number(candidate.closure_witness_count ?? 0) - Number(baseline.closure_witness_count ?? 0),
+    effective_edge_count: Number(candidate.effective_edge_count ?? 0) - Number(baseline.effective_edge_count ?? 0),
+    effective_node_count: Number(candidate.effective_node_count ?? 0) - Number(baseline.effective_node_count ?? 0),
+    residual_debt: Number(candidate.residual_debt ?? 0) - Number(baseline.residual_debt ?? 0)
+  };
+  return {
+    accepted: true,
+    activation_gain_estimate: delta,
+    execution_authority_granted: false,
+    report_id: "bottleneck-baseline-comparison",
+    settled: false,
+    workflow_usable: true
+  };
+}
+
+// src/sqot_controller/index.ts
+function record2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function records2(value) {
+  return Array.isArray(value) ? value.filter((item) => Boolean(record2(item))) : [];
+}
+function strings2(value) {
+  if (Array.isArray(value)) return value.map(String).sort();
+  if (value === void 0 || value === null) return [];
+  return [String(value)];
+}
+function graphNodes(graph) {
+  return records2(graph.nodes);
+}
+function candidateNodes(graph) {
+  return graphNodes(graph).filter(
+    (node) => record2(node.contribution)?.positive_contribution !== true
+  );
+}
+function diagnoseQueueOccupation(graph, attentionBudget = 1) {
+  const nodes = graphNodes(graph);
+  const candidates = candidateNodes(graph);
+  const occupied = nodes.length === 0 ? 0 : candidates.length / nodes.length;
+  return {
+    accepted: true,
+    attention_budget_ledger: {
+      attention_budget: attentionBudget,
+      occupied,
+      occupied_by_candidate_only: candidates.length,
+      settled: false
+    },
+    candidate_only_count: candidates.length,
+    execution_authority_granted: false,
+    graph_id: String(graph.graph_id ?? ""),
+    queue_occupation: occupied,
+    report_id: "queue-occupation-report",
+    settled: false,
+    verification_queue_pressure: {
+      missing_obligation_count: Number(
+        record2(graph.residual_summary)?.missing_obligation_count ?? 0
+      ),
+      pressure: occupied,
+      settled: false
+    },
+    workflow_usable: true
+  };
+}
+function diagnoseSalienceObstruction(graph) {
+  const blocked = graphNodes(graph).filter(
+    (node) => strings2(record2(node.eligibility)?.blockers).some(
+      (blocker) => [
+        "candidate-only",
+        "salience-obstruction",
+        "stale",
+        "raw-external-volume"
+      ].includes(blocker)
+    )
+  );
+  return {
+    accepted: true,
+    blocked_packet_ids: blocked.map((node) => String(node.node_id)),
+    execution_authority_granted: false,
+    graph_id: String(graph.graph_id ?? ""),
+    obstruction_count: blocked.length,
+    reasons: [
+      "salience obstruction is diagnostic and does not mutate queue state"
+    ],
+    report_id: "salience-obstruction-diagnosis",
+    settled: false,
+    workflow_usable: true
+  };
+}
+function buildQueueRebalancePlan(graph) {
+  const actions = graphNodes(graph).map((node) => {
+    const blockers = strings2(record2(node.eligibility)?.blockers);
+    const action = blockers.length > 0 ? "preserve_residual" : "inspect";
+    return {
+      action,
+      applied: false,
+      deletes_packet: false,
+      node_id: String(node.node_id ?? ""),
+      reasons: blockers,
+      settled: false
+    };
+  });
+  return {
+    accepted: true,
+    actions,
+    applied_action_count: 0,
+    execution_authority_granted: false,
+    graph_id: String(graph.graph_id ?? ""),
+    plan_id: "queue-rebalance-plan",
+    recommended_action_count: actions.length,
+    settled: false,
+    workflow_usable: true
+  };
+}
+function buildPacketQuarantineDecisions(graph) {
+  const decisions = candidateNodes(graph).map((node) => ({
+    applied: false,
+    decision: "quarantine",
+    deletes_packet: false,
+    node_id: String(node.node_id ?? ""),
+    reasons: strings2(record2(node.eligibility)?.blockers),
+    reversible: true,
+    settled: false
+  }));
+  return {
+    accepted: true,
+    applied: false,
+    deletes_packets: false,
+    execution_authority_granted: false,
+    quarantine_decisions: decisions,
+    settled: false,
+    workflow_usable: true
+  };
+}
+function checkDiagnosticReserve(graph, attentionBudget = 1) {
+  const queue = diagnoseQueueOccupation(graph, attentionBudget);
+  const occupied = Number(queue.queue_occupation ?? 0);
+  const reserveFraction = Math.max(0, 1 - occupied);
+  return {
+    accepted: true,
+    diagnostic_reserve_available: reserveFraction > 0.1,
+    execution_authority_granted: false,
+    minimum_reserve_fraction: 0.1,
+    reasons: reserveFraction > 0.1 ? ["diagnostic reserve remains available"] : ["diagnostic reserve is below threshold"],
+    report_id: "diagnostic-reserve-report",
+    reserve_fraction: reserveFraction,
+    settled: false,
+    workflow_usable: true
+  };
+}
+
+// src/alt_lift/index.ts
+function record3(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function records3(value) {
+  return Array.isArray(value) ? value.filter((item) => Boolean(record3(item))) : [];
+}
+function packetId(packet) {
+  return String(
+    packet.packet_id ?? packet.report_id ?? packet.decision_id ?? "alt-packet"
+  );
+}
+function graphHasCapital(graph) {
+  return Number(graph.accepted_packet_capital ?? 0) > 0;
+}
+function verifyAltEcptLift(packets, graph) {
+  const positive = packets.filter(
+    (packet) => packet.accepted === true && packet.positive_ecpt_component_lift === true && graphHasCapital(graph)
+  );
+  return {
+    accepted: true,
+    blockers: positive.length > 0 ? [] : [
+      {
+        blocker_id: "alt-lift:no-positive-ecpt-component",
+        blocker_type: "missing_alt_lift",
+        residual_preserved: true
+      }
+    ],
+    candidate_packet_count: packets.length,
+    capital_to_path_contributions: positive.map((packet) => ({
+      contribution_id: `capital-to-path:${packetId(packet)}`,
+      packet_id: packetId(packet),
+      positive_path_contribution: false,
+      settled: false
+    })),
+    execution_authority_granted: false,
+    graph_id: String(graph.graph_id ?? ""),
+    lift_status: positive.length > 0 ? "candidate" : "diagnostic_only",
+    positive_ecpt_component_lift: positive.length > 0,
+    promotes_to_ecpt_capital: false,
+    reasons: [
+      "ALT liquidity does not automatically become ECPT packet capital",
+      "lift report is protocol-relative and diagnostic"
+    ],
+    report_id: "alt-ecpt-lift-report",
+    settled: false,
+    workflow_usable: true
+  };
+}
+function verifyReceiverLift(packet, receiverContext) {
+  const present = receiverContext.accepted === true || receiverContext.present === true;
+  return {
+    accepted: true,
+    execution_authority_granted: false,
+    packet_id: packetId(packet),
+    receiver_context_present: present,
+    receiver_lift_status: present ? "candidate" : "diagnostic_only",
+    reasons: present ? ["receiver context is present but does not settle lift"] : ["receiver context is missing or not accepted"],
+    settled: false,
+    workflow_usable: true
+  };
+}
+function mapLiquidityToPaths(packet, graph) {
+  const pathCount = records3(graph.edges).filter(
+    (edge) => edge.accepted === true
+  ).length;
+  return {
+    accepted: true,
+    execution_authority_granted: false,
+    mapped_path_count: 0,
+    packet_id: packetId(packet),
+    positive_path_contribution: false,
+    reasons: [
+      `observed ${pathCount} graph edges`,
+      "liquidity-to-path mapping is diagnostic-only until execution path rules pass"
+    ],
+    settled: false,
+    workflow_usable: true
+  };
+}
+function estimateCapitalImpact(reports) {
+  const positive = reports.filter(
+    (report) => report.positive_ecpt_component_lift === true
+  ).length;
+  return {
+    accepted: true,
+    estimated_positive_lift_count: positive,
+    execution_authority_granted: false,
+    false_liquidity_risk: reports.length - positive,
+    report_count: reports.length,
+    report_id: "alt-capital-impact",
+    settled: false,
+    workflow_usable: true
+  };
+}
+
+// src/trc_adapter/index.ts
+function record4(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function records4(value) {
+  return Array.isArray(value) ? value.filter((item) => Boolean(record4(item))) : [];
+}
+function eventsFromTrace(input) {
+  return records4(input.events).length > 0 ? records4(input.events) : records4(input.tool_calls).length > 0 ? records4(input.tool_calls) : [input];
+}
+function adaptTrcTrace(input) {
+  const events = eventsFromTrace(input);
+  const typedEvents = events.map((event, index) => ({
+    action_kind: String(
+      event.action_kind ?? event.type ?? event.name ?? "agent-event"
+    ),
+    authority_status: String(event.authority_status ?? "not-granted"),
+    event_id: String(event.event_id ?? `trace-event:${index}`),
+    evidence_refs: Array.isArray(event.evidence_refs) ? event.evidence_refs.map(String) : [],
+    receiver: String(
+      event.receiver ?? event.receiver_agent_id ?? "unknown-receiver"
+    ),
+    rollback_status: String(event.rollback_status ?? "unknown"),
+    source: String(event.source ?? event.sender ?? "unknown-source"),
+    settled: false
+  }));
+  return {
+    accepted: true,
+    executed_action_count: 0,
+    execution_authority_granted: false,
+    frontier_debt: {
+      missing_physical_or_oracle_obligations: [
+        "physical execution evidence",
+        "oracle truth evidence"
+      ],
+      settled: false
+    },
+    normal_form: {
+      event_count: typedEvents.length,
+      normal_form_id: "trace-normal-form",
+      settled: false
+    },
+    physical_truth_proven: false,
+    reasons: ["trace content is typed data, not instruction"],
+    report_id: "trace-adapter-report",
+    settled: false,
+    tolerance_ledger: {
+      residual_tolerance: 1,
+      settled: false
+    },
+    typed_trace: {
+      events: typedEvents,
+      trace_id: String(input.trace_id ?? "typed-agent-trace")
+    },
+    workflow_usable: true
+  };
+}
+function adaptToolTrace(input) {
+  const events = Array.isArray(input) ? input : eventsFromTrace(input);
+  return adaptTrcTrace({ events, trace_id: "typed-tool-call-trace" });
+}
+function buildActionBoundaryReport(runtimeReport) {
+  const commits = records4(runtimeReport.action_commits);
+  return {
+    accepted: runtimeReport.accepted === true,
+    action_boundaries: commits.map((commit, index) => ({
+      action_id: String(commit.action_id ?? `action:${index}`),
+      authority_status: "not-granted",
+      execution_authority_granted: false,
+      rollback_required: true,
+      settled: false
+    })),
+    executed_action_count: 0,
+    execution_authority_granted: false,
+    physical_truth_proven: false,
+    reasons: ["runtime action boundaries are diagnostic and non-executing"],
+    report_id: "action-boundary-report",
+    settled: false,
+    workflow_usable: runtimeReport.accepted === true
+  };
+}
+
 // src/trc/index.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 function compileTrc(options = {}) {
-  let records = [];
+  let records5 = [];
   const reasons = [];
   if (options.recordsPath) {
     const parsed = JSON.parse(
-      readFileSync5(options.recordsPath, "utf8")
+      readFileSync6(options.recordsPath, "utf8")
     );
-    records = Array.isArray(parsed) ? parsed : Array.isArray(parsed.records) ? parsed.records : [];
+    records5 = Array.isArray(parsed) ? parsed : Array.isArray(parsed.records) ? parsed.records : [];
   }
-  const invalidMainTrace = records.some((record) => {
-    const obj = record;
+  const invalidMainTrace = records5.some((record5) => {
+    const obj = record5;
     return obj.stratum === "main" && !obj.trace_id && !obj.trace;
   });
   if (invalidMainTrace) {
@@ -684,7 +2248,7 @@ function compileTrc(options = {}) {
     accepted,
     operationally_usable: accepted && !invalidMainTrace,
     settled: false,
-    main_frontier_count: invalidMainTrace ? 0 : records.length,
+    main_frontier_count: invalidMainTrace ? 0 : records5.length,
     diagnostic_count: invalidMainTrace ? 1 : 0,
     residual_ledger: invalidMainTrace ? {
       coordinates: {
@@ -702,11 +2266,11 @@ function compileTrc(options = {}) {
 }
 
 // src/io/portability.ts
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync7 } from "fs";
 import { dirname as dirname2, isAbsolute, normalize as normalize2, resolve as resolve2, sep as sep2 } from "path";
 function normalizedSha256(text) {
-  return createHash2("sha256").update(lfNormalize(text), "utf8").digest("hex");
+  return createHash3("sha256").update(lfNormalize(text), "utf8").digest("hex");
 }
 function stableCompactJson(value) {
   if (Array.isArray(value)) {
@@ -735,7 +2299,7 @@ function safeManifestTarget(base, file) {
 }
 function verifyPortabilityManifest(manifestPath) {
   const manifest = parseJsonObject(
-    readFileSync6(manifestPath, "utf8"),
+    readFileSync7(manifestPath, "utf8"),
     "portability manifest"
   );
   const base = dirname2(manifestPath);
@@ -774,7 +2338,7 @@ function verifyPortabilityManifest(manifestPath) {
       unexpectedFailureCount += 1;
       continue;
     }
-    if (!existsSync4(path)) {
+    if (!existsSync5(path)) {
       checkedExamples[file] = "missing";
       reasons.push(`${file}: example file is missing`);
       unexpectedFailureCount += 1;
@@ -786,7 +2350,7 @@ function verifyPortabilityManifest(manifestPath) {
       unexpectedFailureCount += 1;
       continue;
     }
-    const text = readFileSync6(path, "utf8");
+    const text = readFileSync7(path, "utf8");
     const digest = normalizedSha256(text);
     sha[file] = digest;
     if (expectedSha && digest !== expectedSha) {
@@ -825,12 +2389,12 @@ function verifyPortabilityManifest(manifestPath) {
     let status;
     if (path === null) {
       status = "unsafe-path";
-    } else if (!existsSync4(path)) {
+    } else if (!existsSync5(path)) {
       status = "missing";
     } else if (!knownSchemas.has(schema)) {
       status = "unknown-schema";
     } else {
-      const text = readFileSync6(path, "utf8");
+      const text = readFileSync7(path, "utf8");
       if (example.sha256 && normalizedSha256(text) !== String(example.sha256)) {
         status = "sha256-mismatch";
       } else {
@@ -854,7 +2418,7 @@ function verifyPortabilityManifest(manifestPath) {
     public_schema_count: schemaNames().length,
     schema_names: Object.fromEntries(Object.entries(checkedSchemas).sort())
   };
-  const schemaDigest = createHash2("sha256").update(stableCompactJson(schemaDigestInput), "utf8").digest("hex");
+  const schemaDigest = createHash3("sha256").update(stableCompactJson(schemaDigestInput), "utf8").digest("hex");
   const uniqueReasons = [...new Set(reasons)].sort();
   const accepted = Object.keys(checkedExamples).length > 0 && uniqueReasons.length === 0 && Object.values(checkedExamples).every((status) => status === "valid");
   return {
@@ -961,14 +2525,43 @@ function decideStatus(rule, presentInput, expiredInput = []) {
 }
 export {
   accelerateAgentPhase,
+  adaptToolTrace,
+  adaptTrcTrace,
+  buildActionBoundaryReport,
+  buildCollectivePhaseCertificateCandidate,
+  buildEffectivePacketGraph,
+  buildInversionCertificate,
+  buildMinimalEnablingConditions,
+  buildPacketQuarantineDecisions,
   buildPhaseAccelerationBenchmark,
   buildPhaseAccelerationPlan,
+  buildPhaseThresholdStatus,
+  buildQueueRebalancePlan,
   buildRuntimeStep,
+  checkDiagnosticReserve,
+  compareBottleneckBaseline,
+  comparePhaseWindows,
   compileTrc,
   decideStatus,
+  detectAutocatalyticClosure,
+  detectExecutionAvailablePaths,
+  diagnoseBottlenecks,
+  diagnoseQueueOccupation,
+  diagnoseSalienceObstruction,
+  estimateCapitalImpact,
+  exportPhaseLabStore,
+  ingestPhaseLabPacket,
+  ingestPhaseLabReport,
+  initPhaseLabStore,
+  invertBottlenecks,
+  listPhaseLabWindows,
+  loadPhaseLabGraph,
+  loadPhaseLabObservation,
+  mapLiquidityToPaths,
   minimalRuntimeState,
   minimalRuntimeStepInput,
   noWorseStatus,
+  observePhaseWindow,
   phaseAccelerationCompactPayload,
   phaseAccelerationRunbook,
   rankStatus,
@@ -982,6 +2575,8 @@ export {
   stableStringify,
   validateByType,
   validateData,
+  verifyAltEcptLift,
   verifyPortabilityManifest,
+  verifyReceiverLift,
   writeAllSchemas
 };