percolation-inversion-compiler-ts 0.4.5 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## v0.5.0
+
+- Tracks the Python `percolation-inversion-compiler==0.5.0` public JSON, CLI, schema, examples, and safety semantics for npm and JavaScript agent runtimes.
+- Adds Phase Ecology Lab support with a local JSON/JSONL store, effective packet graphs, window observations, closure checks, execution-available path detection, threshold status, and certificate candidates.
+- Adds Node-friendly SDK and CLI surfaces for BIT, SQOT, ALT lift, TRC adapter, and ecology graph/path diagnostics.
+- Adds Python v0.5.0-derived schemas, examples, portability fixtures, snapshot fixtures, installed smoke coverage, and package safety checks.
+- Keeps candidate-only, diagnostic, and execution-path outputs inert: they do not run commands, grant execution authority, or mark reports as settled.
+
 ## v0.4.5
 
 - Fixes `agent_output_digest` to use a real SHA-256 digest.

package/README.md

@@ -8,9 +8,9 @@ structured JSON reports. The reports show what is accepted, what is usable for a
 workflow, what still needs checking, and what must not be treated as completed
 work.
 
-This npm package is a TypeScript-compatible port of the Python v0.4.4 public
-JSON, CLI, schema, conformance, and safety semantics. The Python package
-remains the canonical implementation:
+This npm package is a TypeScript-compatible port of the Python v0.5.0 public
+JSON, CLI, schema, conformance, and safety semantics for npm and JavaScript
+agent runtimes. The Python package remains the canonical implementation:
 
 - Canonical repository:
   [kadubon/percolation-inversion-compiler](https://github.com/kadubon/percolation-inversion-compiler)
@@ -32,6 +32,8 @@ In plain terms, it answers:
 - Which command or SDK call can inspect the next step?
 - Which content must remain candidate-only and not be promoted to completed
   work?
+- How do accepted packets, missing evidence, and blocked execution paths look
+  across a local Phase Ecology Lab window?
 
 The package is local-first and Python-free at runtime. It does not execute
 arbitrary shell commands, mutate repositories, crawl in the background, or prove
@@ -45,16 +47,21 @@ Install from npm:
 npm install percolation-inversion-compiler-ts
 ```
 
-Run a compact agent check:
+Create local demo files. This works from any new npm project and does not need
+Python:
 
 ```sh
-npx pic-ts agent check --compact --text "Candidate packet: preserve residuals." --profile development
+npx pic-ts demo bootstrap --output-dir .pic-demo --overwrite
 ```
 
-Plan the next workflow step:
+Run the first local checks:
 
 ```sh
-npx pic-ts phase plan --compact --text "Candidate packet: preserve residuals." --profile development
+npx pic-ts agent check --compact --text "Candidate packet: preserve residuals." --profile development
+npx pic-ts runtime step --state .pic-demo/runtime_state.json --input .pic-demo/runtime_step_input.json --output .pic-demo/runtime_step_report.generated.json
+npx pic-ts packet export --report .pic-demo/runtime_step_report.generated.json --output .pic-demo/packet.json
+npx pic-ts packet inspect --packet .pic-demo/packet.json
+npx pic-ts phase plan --request .pic-demo/asi_proxy_phase_request.json --compact
 ```
 
 The package exposes two command names:
@@ -86,6 +93,30 @@ is preserved, missing work is kept visible, and bottlenecks are routed to finite
 checks. It is not a claim that real ASI, physical outcomes, simulator truth, or
 oracle truth has been proven.
 
+## Run The Phase Ecology Lab
+
+Version 0.5.0 adds a local JSON/JSONL lab for comparing agent reports over a
+small observation window. It stores only JSON records and source file basenames.
+It does not store absolute local paths, run packet content, or turn candidate
+traffic into accepted progress.
+
+```sh
+npx pic-ts demo bootstrap --output-dir .pic-demo --overwrite
+npx pic-ts runtime step --state .pic-demo/runtime_state.json --input .pic-demo/runtime_step_input.json --output .pic-demo/runtime_step_report.generated.json
+npx pic-ts phase lab init --output-dir .pic-lab
+npx pic-ts phase lab ingest --store .pic-lab --report .pic-demo/runtime_step_report.generated.json
+npx pic-ts phase lab graph --store .pic-lab
+npx pic-ts phase lab observe --store .pic-lab
+npx pic-ts phase lab closure --store .pic-lab
+npx pic-ts phase lab executable-paths --store .pic-lab
+npx pic-ts phase lab certify --store .pic-lab --threshold .pic-demo/asi_proxy_development.json
+```
+
+The lab output is useful for routing follow-up checks: which packets contribute,
+which ones are only candidates, which evidence is missing, and which execution
+paths are only available as typed data. The lab keeps `settled=false` unless a
+scoped finite verifier path actually discharges its obligations.
+
 ## Common Commands
 
 Check agent output:
@@ -104,27 +135,43 @@ npx pic-ts phase gap --compact --profile development
 npx pic-ts phase runbook --profile development
 ```
 
-Run the bundled runtime fixture:
+Run a runtime check from files created by `demo bootstrap`:
 
 ```sh
-npx pic-ts runtime step --state fixtures/python_v044_demo/runtime_state.json --input fixtures/python_v044_demo/runtime_step_input.json
+npx pic-ts demo bootstrap --output-dir .pic-demo --overwrite
+npx pic-ts runtime step --state .pic-demo/runtime_state.json --input .pic-demo/runtime_step_input.json --output .pic-demo/runtime_step_report.generated.json
 ```
 
 Work with packets as data:
 
 ```sh
-npx pic-ts packet export --report fixtures/python_v044_demo/runtime_step_report.json --output packet.json
-npx pic-ts packet inspect --packet packet.json
+npx pic-ts packet export --report .pic-demo/runtime_step_report.generated.json --output .pic-demo/packet.json
+npx pic-ts packet inspect --packet .pic-demo/packet.json
 ```
 
-Inspect schemas and conformance fixtures:
+Inspect schemas and the local snapshot catalog:
 
 ```sh
 npx pic-ts schema --type PhaseAccelerationPlan
-npx pic-ts portability verify --manifest fixtures/portability_conformance/manifest.json
+npx pic-ts schema --type EffectivePacketGraph
 npx pic-ts snapshot list
 ```
 
+Use v0.5.0 diagnostic helpers from a repository checkout or from packaged
+examples under `node_modules/percolation-inversion-compiler-ts/examples`:
+
+```sh
+npx pic-ts bit diagnose --graph examples/phase_lab/effective_graph.example.json
+npx pic-ts sqot diagnose-queue --graph examples/phase_lab/effective_graph.example.json
+npx pic-ts alt ecpt-lift --packets examples/alt_lift/alt_ecpt_lift.example.json
+npx pic-ts trc trace-adapter --input examples/trc_adapter/tool_trace_input.example.json
+npx pic-ts ecology execution-available-paths --graph examples/phase_lab/effective_graph.example.json
+```
+
+For installed npm projects, the main path is `demo bootstrap`: it creates the
+runtime state, runtime input, phase request, and threshold files in your current
+project so the commands above do not depend on a cloned repository.
+
 ## Use From JavaScript
 
 Root import:
@@ -156,6 +203,11 @@ Subpath imports for agent runtimes:
 import { schemaByType } from "percolation-inversion-compiler-ts/schema";
 import { createAgentMessage } from "percolation-inversion-compiler-ts/agent/messages";
 import { packetEnvelopeFromRuntimeReport } from "percolation-inversion-compiler-ts/packet";
+import { buildEffectivePacketGraph } from "percolation-inversion-compiler-ts/phase-lab";
+import { diagnoseBottlenecks } from "percolation-inversion-compiler-ts/bit-engine";
+import { diagnoseQueueOccupation } from "percolation-inversion-compiler-ts/sqot-controller";
+import { verifyAltEcptLift } from "percolation-inversion-compiler-ts/alt-lift";
+import { adaptToolTrace } from "percolation-inversion-compiler-ts/trc-adapter";
 ```
 
 ## How To Read The JSON
@@ -198,7 +250,7 @@ missing obligations.
 ## Python Canonical Implementation
 
 The canonical implementation is the Python package
-`percolation-inversion-compiler==0.4.4`.
+`percolation-inversion-compiler==0.5.0`.
 
 Use the Python project when you need the canonical source implementation,
 Python SDK behavior, optional Python sidecars, or the full project
@@ -215,13 +267,15 @@ not copy Python internals line by line.
 
 ## Compatibility
 
-| Command family                                                                                                                                                                                        | Compatibility claim                                                                                         |
-| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
-| `agent check`, `agent intake`, `agent runbook`, `agent autonomy-audit`, `agent manifest`, `agent communication-guide`                                                                                 | Exact Python v0.4.4 golden JSON for bundled fixture-backed modes.                                           |
-| `phase plan`, `phase gap`, `phase runbook`, `phase benchmark`, `phase benchmark-suite`, `phase dashboard`, `phase observe`                                                                            | Exact Python v0.4.4 golden JSON for static fixtures; dynamic `--request` preserves public v0.4.4 semantics. |
-| `runtime step`, `schema`, `snapshot`, `routes`, `portability`, `adoption`, `identity`, `demo installed-smoke`                                                                                         | Python v0.4.4 golden JSON or bundled canonical schema and fixture semantics.                                |
-| `agent message`, `agent inbox`, `packet`, Node-only demo bootstrap                                                                                                                                    | npm/Node sidecar implementation with the same non-promotion and residual-preservation rules.                |
-| evidence heavy routes, runtime service/store/heavy actions, SQOT audit, ALT heavy routes, ecology heavy routes, ECPT heavy routes, audit/extract/check/coverage/parse/provenance/sbom/demo datacenter | Safe diagnostic compatibility only.                                                                         |
+| Command family                                                                                                                                                                                        | Compatibility claim                                                                                       |
+| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `agent check`, `agent intake`, `agent runbook`, `agent autonomy-audit`, `agent manifest`, `agent communication-guide`                                                                                 | Python v0.5.0 public JSON meaning, with v0.4.4 fixture-backed parity preserved.                           |
+| `phase plan`, `phase gap`, `phase runbook`, `phase benchmark`, `phase benchmark-suite`, `phase dashboard`, `phase observe`                                                                            | Python v0.5.0 public semantics; dynamic `--request` keeps candidate-only and identity blockers visible.   |
+| `phase lab init/ingest/list-windows/export/observe/graph/closure/executable-paths/threshold-status/certify/compare-window`                                                                            | npm/Node JSON/JSONL local store for Python v0.5.0 Phase Ecology Lab records.                              |
+| `bit`, `sqot`, `alt`, `trc`, `ecology effective-graph`, `ecology execution-available-paths`                                                                                                           | v0.5.0 diagnostic and recommendation routes; outputs are inert JSON and do not grant execution authority. |
+| `runtime step`, `schema`, `snapshot`, `routes`, `portability`, `adoption`, `identity`, `demo installed-smoke`                                                                                         | Python v0.5.0-compatible schema and fixture semantics, with bundled v0.4.4/v0.5.0 conformance fixtures.   |
+| `agent message`, `agent inbox`, `packet`, Node-only demo bootstrap                                                                                                                                    | npm/Node sidecar implementation with the same non-promotion and residual-preservation rules.              |
+| evidence heavy routes, runtime service/store/heavy actions, SQOT audit, ALT heavy routes, ecology heavy routes, ECPT heavy routes, audit/extract/check/coverage/parse/provenance/sbom/demo datacenter | Safe diagnostic compatibility only.                                                                       |
 
 ## Development And Publishing Checks
 
@@ -254,4 +308,5 @@ unresolved work ledger, missing obligations, packet export, packet inspection,
 agent-to-agent message checking, runtime step report, phase planning, workflow
 bottleneck planning, portability conformance, JSON schema validation,
 percolation inversion compiler, PIC, ECPT, BIT, TRC, SQOT, ALT, ASI-proxy
-workflow loop.
+workflow loop, Phase Ecology Lab, effective packet graph, execution available
+paths, bottleneck inversion, salience queue, typed runtime trace.

package/agent-manifest.json

@@ -0,0 +1,50 @@
+{
+  "manifest_id": "pic-ts-agent-manifest-v050",
+  "package_name": "percolation-inversion-compiler-ts",
+  "version": "0.5.0",
+  "recommended_cli": "pic-ts",
+  "compatibility_alias": "pic",
+  "canonical_python_package": "percolation-inversion-compiler==0.5.0",
+  "purpose": "Local JSON checker and workflow report generator for JavaScript and TypeScript agent runtimes.",
+  "safe_entrypoints": [
+    "pic-ts agent check --compact",
+    "pic-ts runtime step --state <state.json> --input <input.json>",
+    "pic-ts packet export --report <report.json> --output <packet.json>",
+    "pic-ts packet inspect --packet <packet.json>",
+    "pic-ts phase lab init --output-dir <phase-lab-dir>",
+    "pic-ts phase lab ingest --store <phase-lab-dir> --report <report.json>",
+    "pic-ts phase lab observe --store <phase-lab-dir> --window latest",
+    "pic-ts phase lab graph --store <phase-lab-dir>",
+    "pic-ts phase lab closure --store <phase-lab-dir>",
+    "pic-ts phase lab executable-paths --store <phase-lab-dir>",
+    "pic-ts phase lab certify --store <phase-lab-dir> --threshold <threshold.json>",
+    "pic-ts phase plan --request <request.json> --compact"
+  ],
+  "sdk_subpaths": [
+    ".",
+    "./schema",
+    "./agent/messages",
+    "./packet",
+    "./phase-lab",
+    "./bit-engine",
+    "./sqot-controller",
+    "./alt-lift",
+    "./trc-adapter"
+  ],
+  "safety_boundary": {
+    "python_required_at_runtime": false,
+    "executes_packet_content": false,
+    "executes_trace_content": false,
+    "grants_shell_authority": false,
+    "mutates_repositories": false,
+    "uses_live_network_connectors_by_default": false,
+    "hidden_settlement": false
+  },
+  "status_rules": [
+    "accepted does not imply settled",
+    "workflow_usable does not imply settled",
+    "operationally_usable does not imply settled",
+    "candidate-only reports remain diagnostic",
+    "raw packet volume does not improve positive phase metrics"
+  ]
+}

package/dist/alt_lift/index.d.ts

@@ -0,0 +1,7 @@
+type JsonRecord = Record<string, unknown>;
+declare function verifyAltEcptLift(packets: JsonRecord[], graph: JsonRecord): JsonRecord;
+declare function verifyReceiverLift(packet: JsonRecord, receiverContext: JsonRecord): JsonRecord;
+declare function mapLiquidityToPaths(packet: JsonRecord, graph: JsonRecord): JsonRecord;
+declare function estimateCapitalImpact(reports: JsonRecord[]): JsonRecord;
+
+export { estimateCapitalImpact, mapLiquidityToPaths, verifyAltEcptLift, verifyReceiverLift };

package/dist/alt_lift/index.js

@@ -0,0 +1,101 @@
+// src/alt_lift/index.ts
+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 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 = records(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
+  };
+}
+export {
+  estimateCapitalImpact,
+  mapLiquidityToPaths,
+  verifyAltEcptLift,
+  verifyReceiverLift
+};

package/dist/bit_engine/index.d.ts

@@ -0,0 +1,8 @@
+type JsonRecord = Record<string, unknown>;
+declare function diagnoseBottlenecks(graph: JsonRecord): JsonRecord;
+declare function buildMinimalEnablingConditions(bottleneckId: string, report?: JsonRecord): JsonRecord[];
+declare function invertBottlenecks(report: JsonRecord): JsonRecord;
+declare function buildInversionCertificate(candidate: JsonRecord): JsonRecord;
+declare function compareBottleneckBaseline(baseline: JsonRecord, candidate: JsonRecord): JsonRecord;
+
+export { buildInversionCertificate, buildMinimalEnablingConditions, compareBottleneckBaseline, diagnoseBottlenecks, invertBottlenecks };

package/dist/bit_engine/index.js

@@ -0,0 +1,213 @@
+// 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
+  };
+}
+export {
+  buildInversionCertificate,
+  buildMinimalEnablingConditions,
+  compareBottleneckBaseline,
+  diagnoseBottlenecks,
+  invertBottlenecks
+};