percolation-inversion-compiler-ts 0.4.5 → 0.5.0

package/dist/cli/main.js

@@ -3,13 +3,13 @@
 // src/cli/main.ts
 import {
   cpSync as cpSync2,
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync9,
-  readdirSync as readdirSync2,
-  writeFileSync as writeFileSync4
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync10,
+  readdirSync as readdirSync3,
+  writeFileSync as writeFileSync5
 } from "fs";
-import { dirname as dirname5, join as join4 } from "path";
+import { dirname as dirname5, join as join5 } from "path";
 import { Command } from "commander";
 
 // src/io/fixtures.ts
@@ -116,9 +116,9 @@ function portabilityManifest() {
 }
 
 // src/alt/index.ts
-function altAdmit(packetId = "alt-packet:demo") {
+function altAdmit(packetId2 = "alt-packet:demo") {
   const decision = structuredClone(fixtureJson("alt_admission_decision.json"));
-  decision.packet_id = packetId;
+  decision.packet_id = packetId2;
   decision.accepted = Boolean(decision.accepted ?? false);
   decision.settled = false;
   decision.reasons = [
@@ -128,6 +128,102 @@ function altAdmit(packetId = "alt-packet:demo") {
   return decision;
 }
 
+// src/alt_lift/index.ts
+function record(value2) {
+  return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : void 0;
+}
+function records(value2) {
+  return Array.isArray(value2) ? value2.filter((item) => Boolean(record(item))) : [];
+}
+function packetId(packet2) {
+  return String(
+    packet2.packet_id ?? packet2.report_id ?? packet2.decision_id ?? "alt-packet"
+  );
+}
+function graphHasCapital(graph) {
+  return Number(graph.accepted_packet_capital ?? 0) > 0;
+}
+function verifyAltEcptLift(packets, graph) {
+  const positive = packets.filter(
+    (packet2) => packet2.accepted === true && packet2.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((packet2) => ({
+      contribution_id: `capital-to-path:${packetId(packet2)}`,
+      packet_id: packetId(packet2),
+      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(packet2, receiverContext) {
+  const present = receiverContext.accepted === true || receiverContext.present === true;
+  return {
+    accepted: true,
+    execution_authority_granted: false,
+    packet_id: packetId(packet2),
+    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(packet2, 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(packet2),
+    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/core/ledger.ts
 function emptyLedger() {
   return { coordinates: {} };
@@ -827,7 +923,7 @@ function verifyAgentMessage(message2, options = {}) {
   }
   reasons.push(...identityReasons);
   const accepted = contract.accepted === true && reasons.length === 0;
-  const packetId = `packet:agent-message:${String(message2.message_id ?? "unknown")}`;
+  const packetId2 = `packet:agent-message:${String(message2.message_id ?? "unknown")}`;
   const packets = contract.accepted === true ? [
     {
       authority_granted: false,
@@ -851,7 +947,7 @@ function verifyAgentMessage(message2, options = {}) {
       issuer_attestation_id: message2.issuer_attestation_id ?? null,
       issuer_public_key_id: message2.issuer_public_key_id ?? null,
       issuer_signature_ref: message2.signature_ref ?? null,
-      packet_id: packetId,
+      packet_id: packetId2,
       receiver_family: Array.isArray(message2.declared_receiver_family) ? message2.declared_receiver_family.map(String) : ["agent", "verifier"],
       residual_charge: 0,
       reuse_context: "general",
@@ -910,15 +1006,15 @@ function verifyAgentMessage(message2, options = {}) {
   };
 }
 function initAgentInbox(path, inboxId = "agent-inbox") {
-  const record = {
+  const record5 = {
     inbox_id: inboxId,
     messages: [],
     peers: [],
     seen_nonces: []
   };
   mkdirSync2(dirname2(path), { recursive: true });
-  writeFileSync2(path, stableStringify(record), "utf8");
-  return record;
+  writeFileSync2(path, stableStringify(record5), "utf8");
+  return record5;
 }
 function readAgentInbox(path) {
   const text = readFileSync5(path, "utf8").trim();
@@ -1048,6 +1144,213 @@ function ecologyPolicy(profile = "controlled_web") {
   };
 }
 
+// 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 record2(value2) {
+  return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : void 0;
+}
+function records2(value2) {
+  return Array.isArray(value2) ? value2.filter((item) => Boolean(record2(item))) : [];
+}
+function strings(value2) {
+  if (Array.isArray(value2)) return value2.map(String).sort();
+  if (value2 === void 0 || value2 === null) return [];
+  return [String(value2)];
+}
+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 records2(graph.nodes)) {
+    for (const blocker of strings(record2(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 = records2(report?.bottlenecks).find(
+    (item) => item.bottleneck_id === bottleneckId
+  );
+  if (found) return records2(found.minimal_enabling_conditions);
+  return minimalConditions(bottleneckId, "external_domain_obligation");
+}
+function invertBottlenecks(report) {
+  const candidates = records2(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 = records2(candidate.inversion_candidates)[0] ?? records2(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/io/portability.ts
 import { createHash as createHash4 } from "crypto";
 import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
@@ -1295,14 +1598,14 @@ function readTypedJson(path, schema) {
   }
   return data;
 }
-function residualCarryForward(reportId, residualSummary, missingObligations, candidateOnlyReasons, settledBlockers, accepted) {
+function residualCarryForward(reportId, residualSummary2, missingObligations, candidateOnlyReasons, settledBlockers, accepted) {
   return {
     accepted,
     candidate_only_reasons: candidateOnlyReasons,
     missing_obligations: missingObligations,
     reasons: ["residuals and blockers are preserved during packet export"],
     report_id: reportId,
-    residual_summary: residualSummary,
+    residual_summary: residualSummary2,
     settled: false,
     settled_blockers: settledBlockers
   };
@@ -1310,7 +1613,7 @@ function residualCarryForward(reportId, residualSummary, missingObligations, can
 function packetEnvelopeFromRuntimeReport(report) {
   const digest = stableDigest(report);
   const missing = Array.isArray(report.missing_obligations) ? report.missing_obligations.map(String) : [];
-  const residualSummary = summarizeLedger(report.residual_ledger);
+  const residualSummary2 = summarizeLedger(report.residual_ledger);
   const candidateOnlyReasons = [
     "runtime report is exported as diagnostic packet-exchange data",
     "packet exchange does not route promotion checks"
@@ -1344,13 +1647,13 @@ function packetEnvelopeFromRuntimeReport(report) {
     reasons: ["exported packet is diagnostic data and is not promoted"],
     residual_carry_forward: residualCarryForward(
       `residual-carry-forward:${reportId}`,
-      residualSummary,
+      residualSummary2,
       missing,
       candidateOnlyReasons,
       settledBlockers,
       report.accepted === true
     ),
-    residual_ledger_summary: residualSummary,
+    residual_ledger_summary: residualSummary2,
     safety_invariants: [
       "packet exchange treats content as inert data",
       "packet exchange does not execute embedded commands",
@@ -1415,7 +1718,7 @@ function mergePacketEnvelopes(envelopes) {
   const byDigest = /* @__PURE__ */ new Map();
   const duplicateIds = [];
   const duplicateDigests = [];
-  const residualSummary = {};
+  const residualSummary2 = {};
   const missing = [];
   const candidateOnly = [];
   const blockers = [];
@@ -1430,7 +1733,7 @@ function mergePacketEnvelopes(envelopes) {
     for (const [key, value2] of Object.entries(
       envelope.residual_ledger_summary ?? {}
     )) {
-      residualSummary[key] = (residualSummary[key] ?? 0) + Number(value2);
+      residualSummary2[key] = (residualSummary2[key] ?? 0) + Number(value2);
     }
     if (Array.isArray(envelope.missing_obligations)) {
       missing.push(...envelope.missing_obligations.map(String));
@@ -1457,7 +1760,7 @@ function mergePacketEnvelopes(envelopes) {
     report_id: "packet-merge-report",
     residual_carry_forward: residualCarryForward(
       "residual-carry-forward:packet-merge",
-      Object.fromEntries(Object.entries(residualSummary).sort()),
+      Object.fromEntries(Object.entries(residualSummary2).sort()),
       sortedUnique2(missing),
       sortedUnique2(candidateOnly),
       sortedUnique2(blockers),
@@ -1469,12 +1772,12 @@ function mergePacketEnvelopes(envelopes) {
 }
 function packetLineageDigest(packetOrMerge) {
   const packets = Array.isArray(packetOrMerge.packets) ? packetOrMerge.packets : [packetOrMerge];
-  const residualSummary = {};
+  const residualSummary2 = {};
   for (const packet2 of packets) {
     for (const [key, value2] of Object.entries(
       packet2.residual_ledger_summary ?? {}
     )) {
-      residualSummary[key] = (residualSummary[key] ?? 0) + Number(value2);
+      residualSummary2[key] = (residualSummary2[key] ?? 0) + Number(value2);
     }
   }
   return {
@@ -1495,134 +1798,1190 @@ function packetLineageDigest(packetOrMerge) {
       "lineage digest is diagnostic-only and preserves candidate status"
     ],
     residual_summary: Object.fromEntries(
-      Object.entries(residualSummary).sort()
+      Object.entries(residualSummary2).sort()
     ),
     settled: false,
     workflow_usable: packets.some((packet2) => packet2.workflow_usable === true)
   };
 }
 
-// src/render/markdown.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname4 } from "path";
-function lang(language) {
-  return language?.toLowerCase().startsWith("ja") ? "ja" : "en";
+// src/phase_lab/index.ts
+import { createHash as createHash6 } from "crypto";
+import {
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync8,
+  readdirSync as readdirSync2,
+  writeFileSync as writeFileSync3
+} 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 createHash6("sha256").update(JSON.stringify(sortJson(data)), "utf8").digest("hex");
 }
-function value(data, key) {
-  const raw = data[key];
-  if (raw === void 0 || raw === null) {
-    return "not-recorded";
+function asRecord(value2) {
+  return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : void 0;
+}
+function asRecords(value2) {
+  return Array.isArray(value2) ? value2.filter((item) => Boolean(asRecord(item))) : [];
+}
+function stringList(value2) {
+  if (value2 === void 0 || value2 === null) return [];
+  if (Array.isArray(value2)) return value2.map(String).sort();
+  if (value2 instanceof Set) return [...value2].map(String).sort();
+  return [String(value2)];
+}
+function numeric(value2) {
+  if (typeof value2 === "number" && Number.isFinite(value2)) return value2;
+  const parsed = Number(value2);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function numericDict(value2) {
+  const record5 = asRecord(value2);
+  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);
   }
-  if (typeof raw === "string" || typeof raw === "number") {
-    return String(raw);
+  return Object.fromEntries(
+    Object.entries(summary).sort(([a], [b]) => a.localeCompare(b))
+  );
+}
+function residualDebt(summary) {
+  return Object.values(summary).reduce((total, value2) => total + value2, 0);
+}
+function inferSchemaHint(payload) {
+  if ("packet_id" in payload && "content_digest" in payload && "content" in payload) {
+    return "PacketExchangeEnvelope";
   }
-  if (typeof raw === "boolean") {
-    return raw ? "true" : "false";
+  if ("report_id" in payload && "registry" in payload)
+    return "RuntimeStepReport";
+  if ("graph_id" in payload && "nodes" in payload && "edges" in payload) {
+    return "EffectivePacketGraph";
   }
-  return JSON.stringify(raw);
+  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 count(data, key) {
-  const raw = data[key];
-  if (Array.isArray(raw)) {
-    return raw.length;
-  }
-  if (raw && typeof raw === "object") {
-    return Object.keys(raw).length;
+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");
   }
-  return 0;
+  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 boolRows(data, keys) {
-  return keys.map((key) => `- \`${key}\`: ${value(data, key)}`).join("\n");
+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 safetyBoundary(language) {
-  if (lang(language) === "ja") {
-    return [
-      "## \u5B89\u5168\u5883\u754C",
-      "",
-      "- \u3053\u308C\u306F\u5B9F\u884C\u6A29\u9650\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002",
-      "- \u5B9F ASI\u3001\u7269\u7406\u7D50\u679C\u3001\u5916\u90E8\u30AA\u30E9\u30AF\u30EB\u306E\u771F\u7406\u3092\u8A3C\u660E\u3057\u307E\u305B\u3093\u3002",
-      "- `settled=false` \u306F\u672A\u89E3\u6C7A\u306E\u78BA\u8A8D\u4E8B\u9805\u304C\u898B\u3048\u308B\u72B6\u614B\u3067\u6B8B\u308B\u3053\u3068\u3092\u610F\u5473\u3057\u307E\u3059\u3002",
-      "- packet \u306E\u5185\u5BB9\u3068 `safe_commands` \u306F\u691C\u67FB\u7528\u30C7\u30FC\u30BF\u3067\u3042\u308A\u3001\u81EA\u52D5\u5B9F\u884C\u3055\u308C\u307E\u305B\u3093\u3002"
-    ].join("\n");
+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 [
-    "## Safety Boundary",
-    "",
-    "- This is not execution authority.",
-    "- This is not proof of real ASI, physical truth, or oracle truth.",
-    "- `settled=false` means unresolved obligations remain visible.",
-    "- Packet content and `safe_commands` are inspection data, not automatic actions."
-  ].join("\n");
+  return parseJsonObject(readFileSync8(path, "utf8"), label);
 }
-function writeTextOutput(text, outputPath) {
-  const finalText = text.endsWith("\n") ? text : `${text}
-`;
-  if (outputPath) {
-    mkdirSync3(dirname4(outputPath), { recursive: true });
-    writeFileSync3(outputPath, finalText, "utf8");
+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 (!existsSync6(eventsPath)) return [];
+  return readFileSync8(eventsPath, "utf8").split(/\r?\n/).filter(Boolean).map((line) => parseJsonObject(line, "phase lab event"));
+}
+function writeJson(path, data) {
+  writeFileSync3(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 (!existsSync6(windowsDir)) return [];
+  return readdirSync2(windowsDir).filter((name) => name !== "latest.json" && name.endsWith(".json")).sort().map(
+    (name) => parseJsonObject(readFileSync8(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 {
-    process.stdout.write(finalText);
+    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 renderAdoptionPacketMarkdown(data, language) {
-  if (lang(language) === "ja") {
-    return [
-      "# \u30AA\u30DA\u30EC\u30FC\u30BF\u30FC\u63A1\u7528\u30D1\u30B1\u30C3\u30C8",
-      "",
-      "PIC-TS \u306F Node.js \u3067 AI agent \u306E\u51FA\u529B\u3092 JSON \u3068\u3057\u3066\u691C\u67FB\u3057\u3001\u672A\u89E3\u6C7A\u306E\u78BA\u8A8D\u4E8B\u9805\u3092\u96A0\u3055\u305A\u6B8B\u3057\u307E\u3059\u3002",
-      "",
-      "## \u6700\u521D\u306E\u30B3\u30DE\u30F3\u30C9",
-      "",
-      "```sh",
-      "npm install percolation-inversion-compiler-ts",
-      "npx pic-ts agent check --compact",
-      "```",
-      "",
-      "## \u72B6\u614B\u306E\u8AAD\u307F\u65B9",
-      "",
-      boolRows(data, ["accepted", "workflow_usable", "settled"]),
-      "- `residual_ledger`: \u6B8B\u3063\u3066\u3044\u308B\u78BA\u8A8D\u4F5C\u696D\u306E\u53F0\u5E33\u3067\u3059\u3002",
-      "- `safe_commands`: \u30AA\u30DA\u30EC\u30FC\u30BF\u30FC\u304C\u78BA\u8A8D\u3059\u308B\u305F\u3081\u306E\u5019\u88DC\u3067\u3042\u308A\u3001\u81EA\u52D5\u5B9F\u884C\u6A29\u9650\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002",
-      "",
-      "## \u30EC\u30D3\u30E5\u30FC\u30C1\u30A7\u30C3\u30AF",
-      "",
-      "- packet \u3092\u4E3B workflow \u306E gate \u3068\u3057\u3066\u6271\u308F\u306A\u3044\u3002",
-      "- \u672A\u89E3\u6C7A obligation \u3092 `settled=true` \u306B\u6607\u683C\u3057\u306A\u3044\u3002",
-      "",
-      safetyBoundary(language)
-    ].join("\n");
-  }
-  return [
-    "# Operator Adoption Packet",
-    "",
-    "PIC-TS checks AI agent output for Node.js workflows and keeps unfinished verification work visible.",
-    "",
-    "## First Commands",
-    "",
-    "```sh",
-    "npm install percolation-inversion-compiler-ts",
-    "npx pic-ts agent check --compact",
-    "```",
-    "",
-    "## How To Read The Report",
-    "",
-    boolRows(data, ["accepted", "workflow_usable", "settled"]),
-    "- `residual_ledger`: remaining verification work that must stay visible.",
-    "- `safe_commands`: inspection hints for an operator, not permission to run actions.",
-    "",
-    "## Operator Review Checklist",
-    "",
-    "- Confirm adoption sidecars do not gate the main workflow.",
-    "- Confirm unresolved obligations are not promoted to settlement.",
-    "",
-    safetyBoundary(language)
-  ].join("\n");
+function writeManifest(storeDir) {
+  const paths = storePaths(storeDir);
+  mkdirSync3(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 renderAdoptionRequestMarkdown(data, language) {
-  if (lang(language) === "ja") {
-    return [
-      "# Agent \u304B\u3089 Operator \u3078\u306E\u30EA\u30AF\u30A8\u30B9\u30C8",
-      "",
+function initPhaseLabStore(outputDir) {
+  const paths = storePaths(outputDir);
+  mkdirSync3(paths.windows, { recursive: true });
+  if (!existsSync6(paths.events)) writeFileSync3(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) {
+    writeFileSync3(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 ingestPhaseLabFiles(storeDir, reportPaths = [], packetPaths = []) {
+  const payloads = [
+    ...reportPaths.map((path) => ({
+      payload: readJsonFile(path, "phase lab report"),
+      path
+    })),
+    ...packetPaths.map((path) => ({
+      payload: readJsonFile(path, "phase lab packet"),
+      path,
+      sourceKind: "packet-exchange"
+    }))
+  ];
+  if (payloads.length === 0) {
+    throw new Error("provide at least one Phase Lab report or packet");
+  }
+  return ingestPayloads(storeDir, payloads);
+}
+function ingestPhaseLabDirectory(storeDir, directory) {
+  if (!existsSync6(directory))
+    throw new Error(`phase lab directory does not exist: ${directory}`);
+  const payloads = readdirSync2(directory).filter((name) => name.toLowerCase().endsWith(".json")).sort().map((name) => {
+    const path = join4(directory, name);
+    return { payload: readJsonFile(path, "phase lab directory item"), path };
+  });
+  return ingestPayloads(storeDir, payloads);
+}
+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, value2] of Object.entries(
+      numericDict(node.residual_summary)
+    )) {
+      mergedResidual[key] = (mergedResidual[key] ?? 0) + value2;
+    }
+  }
+  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(
+      (evidence2) => Boolean(evidence2?.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, value2]) => key !== "residual_debt" && value2 > 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) {
+  mkdirSync3(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/render/markdown.ts
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname4 } from "path";
+function lang(language) {
+  return language?.toLowerCase().startsWith("ja") ? "ja" : "en";
+}
+function value(data, key) {
+  const raw = data[key];
+  if (raw === void 0 || raw === null) {
+    return "not-recorded";
+  }
+  if (typeof raw === "string" || typeof raw === "number") {
+    return String(raw);
+  }
+  if (typeof raw === "boolean") {
+    return raw ? "true" : "false";
+  }
+  return JSON.stringify(raw);
+}
+function count(data, key) {
+  const raw = data[key];
+  if (Array.isArray(raw)) {
+    return raw.length;
+  }
+  if (raw && typeof raw === "object") {
+    return Object.keys(raw).length;
+  }
+  return 0;
+}
+function boolRows(data, keys) {
+  return keys.map((key) => `- \`${key}\`: ${value(data, key)}`).join("\n");
+}
+function safetyBoundary(language) {
+  if (lang(language) === "ja") {
+    return [
+      "## \u5B89\u5168\u5883\u754C",
+      "",
+      "- \u3053\u308C\u306F\u5B9F\u884C\u6A29\u9650\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002",
+      "- \u5B9F ASI\u3001\u7269\u7406\u7D50\u679C\u3001\u5916\u90E8\u30AA\u30E9\u30AF\u30EB\u306E\u771F\u7406\u3092\u8A3C\u660E\u3057\u307E\u305B\u3093\u3002",
+      "- `settled=false` \u306F\u672A\u89E3\u6C7A\u306E\u78BA\u8A8D\u4E8B\u9805\u304C\u898B\u3048\u308B\u72B6\u614B\u3067\u6B8B\u308B\u3053\u3068\u3092\u610F\u5473\u3057\u307E\u3059\u3002",
+      "- packet \u306E\u5185\u5BB9\u3068 `safe_commands` \u306F\u691C\u67FB\u7528\u30C7\u30FC\u30BF\u3067\u3042\u308A\u3001\u81EA\u52D5\u5B9F\u884C\u3055\u308C\u307E\u305B\u3093\u3002"
+    ].join("\n");
+  }
+  return [
+    "## Safety Boundary",
+    "",
+    "- This is not execution authority.",
+    "- This is not proof of real ASI, physical truth, or oracle truth.",
+    "- `settled=false` means unresolved obligations remain visible.",
+    "- Packet content and `safe_commands` are inspection data, not automatic actions."
+  ].join("\n");
+}
+function writeTextOutput(text, outputPath) {
+  const finalText = text.endsWith("\n") ? text : `${text}
+`;
+  if (outputPath) {
+    mkdirSync4(dirname4(outputPath), { recursive: true });
+    writeFileSync4(outputPath, finalText, "utf8");
+  } else {
+    process.stdout.write(finalText);
+  }
+}
+function renderAdoptionPacketMarkdown(data, language) {
+  if (lang(language) === "ja") {
+    return [
+      "# \u30AA\u30DA\u30EC\u30FC\u30BF\u30FC\u63A1\u7528\u30D1\u30B1\u30C3\u30C8",
+      "",
+      "PIC-TS \u306F Node.js \u3067 AI agent \u306E\u51FA\u529B\u3092 JSON \u3068\u3057\u3066\u691C\u67FB\u3057\u3001\u672A\u89E3\u6C7A\u306E\u78BA\u8A8D\u4E8B\u9805\u3092\u96A0\u3055\u305A\u6B8B\u3057\u307E\u3059\u3002",
+      "",
+      "## \u6700\u521D\u306E\u30B3\u30DE\u30F3\u30C9",
+      "",
+      "```sh",
+      "npm install percolation-inversion-compiler-ts",
+      "npx pic-ts agent check --compact",
+      "```",
+      "",
+      "## \u72B6\u614B\u306E\u8AAD\u307F\u65B9",
+      "",
+      boolRows(data, ["accepted", "workflow_usable", "settled"]),
+      "- `residual_ledger`: \u6B8B\u3063\u3066\u3044\u308B\u78BA\u8A8D\u4F5C\u696D\u306E\u53F0\u5E33\u3067\u3059\u3002",
+      "- `safe_commands`: \u30AA\u30DA\u30EC\u30FC\u30BF\u30FC\u304C\u78BA\u8A8D\u3059\u308B\u305F\u3081\u306E\u5019\u88DC\u3067\u3042\u308A\u3001\u81EA\u52D5\u5B9F\u884C\u6A29\u9650\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002",
+      "",
+      "## \u30EC\u30D3\u30E5\u30FC\u30C1\u30A7\u30C3\u30AF",
+      "",
+      "- packet \u3092\u4E3B workflow \u306E gate \u3068\u3057\u3066\u6271\u308F\u306A\u3044\u3002",
+      "- \u672A\u89E3\u6C7A obligation \u3092 `settled=true` \u306B\u6607\u683C\u3057\u306A\u3044\u3002",
+      "",
+      safetyBoundary(language)
+    ].join("\n");
+  }
+  return [
+    "# Operator Adoption Packet",
+    "",
+    "PIC-TS checks AI agent output for Node.js workflows and keeps unfinished verification work visible.",
+    "",
+    "## First Commands",
+    "",
+    "```sh",
+    "npm install percolation-inversion-compiler-ts",
+    "npx pic-ts agent check --compact",
+    "```",
+    "",
+    "## How To Read The Report",
+    "",
+    boolRows(data, ["accepted", "workflow_usable", "settled"]),
+    "- `residual_ledger`: remaining verification work that must stay visible.",
+    "- `safe_commands`: inspection hints for an operator, not permission to run actions.",
+    "",
+    "## Operator Review Checklist",
+    "",
+    "- Confirm adoption sidecars do not gate the main workflow.",
+    "- Confirm unresolved obligations are not promoted to settlement.",
+    "",
+    safetyBoundary(language)
+  ].join("\n");
+}
+function renderAdoptionRequestMarkdown(data, language) {
+  if (lang(language) === "ja") {
+    return [
+      "# Agent \u304B\u3089 Operator \u3078\u306E\u30EA\u30AF\u30A8\u30B9\u30C8",
+      "",
       "agent \u306F PIC-TS \u3092\u898B\u3064\u3051\u307E\u3057\u305F\u304C\u3001install \u3084 tool \u5B9F\u884C\u306E\u6A29\u9650\u306F operator \u306E\u78BA\u8A8D\u304C\u5FC5\u8981\u3067\u3059\u3002",
       "",
       "## \u4F9D\u983C",
@@ -1796,19 +3155,154 @@ function buildSalienceSchedule(profile = "production") {
   return report;
 }
 
+// src/sqot_controller/index.ts
+function record3(value2) {
+  return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : void 0;
+}
+function records3(value2) {
+  return Array.isArray(value2) ? value2.filter((item) => Boolean(record3(item))) : [];
+}
+function strings2(value2) {
+  if (Array.isArray(value2)) return value2.map(String).sort();
+  if (value2 === void 0 || value2 === null) return [];
+  return [String(value2)];
+}
+function graphNodes(graph) {
+  return records3(graph.nodes);
+}
+function candidateNodes(graph) {
+  return graphNodes(graph).filter(
+    (node) => record3(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(
+        record3(graph.residual_summary)?.missing_obligation_count ?? 0
+      ),
+      pressure: occupied,
+      settled: false
+    },
+    workflow_usable: true
+  };
+}
+function diagnoseSalienceObstruction(graph) {
+  const blocked = graphNodes(graph).filter(
+    (node) => strings2(record3(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(record3(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(record3(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/trc/index.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 function compileTrc(options = {}) {
-  let records = [];
+  let records5 = [];
   const reasons = [];
   if (options.recordsPath) {
     const parsed = JSON.parse(
-      readFileSync8(options.recordsPath, "utf8")
+      readFileSync9(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) {
@@ -1822,7 +3316,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: {
@@ -1839,13 +3333,95 @@ function compileTrc(options = {}) {
   };
 }
 
+// src/trc_adapter/index.ts
+function record4(value2) {
+  return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : void 0;
+}
+function records4(value2) {
+  return Array.isArray(value2) ? value2.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/cli/main.ts
-var VERSION = "0.4.5";
+var VERSION = "0.5.0";
 function outputJson(data, output) {
   const text = stableStringify(data);
   if (output) {
-    mkdirSync4(dirname5(output), { recursive: true });
-    writeFileSync4(output, text, "utf8");
+    mkdirSync5(dirname5(output), { recursive: true });
+    writeFileSync5(output, text, "utf8");
   } else {
     process.stdout.write(text);
   }
@@ -1858,7 +3434,7 @@ function readText(options, fallback = "Candidate packet: preserve residuals.") {
     return options.text;
   }
   if (typeof options.textFile === "string") {
-    return readFileSync9(options.textFile, "utf8");
+    return readFileSync10(options.textFile, "utf8");
   }
   return fallback;
 }
@@ -1928,7 +3504,19 @@ function boolOptionOrRequest(optionValue, requestValue) {
   return typeof optionValue === "boolean" ? optionValue : void 0;
 }
 function readPhaseRequest(path) {
-  return parseJsonObject(readFileSync9(path, "utf8"), "phase request");
+  return parseJsonObject(readFileSync10(path, "utf8"), "phase request");
+}
+function readJsonPath(path, label = "JSON") {
+  return parseJsonObject(readFileSync10(path, "utf8"), label);
+}
+function readJsonPaths(value2, label) {
+  if (!value2) {
+    return [];
+  }
+  const paths = Array.isArray(value2) ? value2 : [value2];
+  return paths.flatMap(
+    (item) => String(item).split(",").filter(Boolean).map((path) => readJsonPath(path, label))
+  );
 }
 function phaseRequestFromCli(options) {
   if (typeof options.request === "string") {
@@ -1951,7 +3539,7 @@ function phaseRequestFromCli(options) {
     };
   }
   const runtimeReport = typeof options.runtimeReport === "string" ? parseJsonObject(
-    readFileSync9(options.runtimeReport, "utf8"),
+    readFileSync10(options.runtimeReport, "utf8"),
     "runtime report"
   ) : void 0;
   return {
@@ -1997,7 +3585,7 @@ function addTextOptions(command) {
 }
 var program = new Command();
 program.name("pic").description(
-  "TypeScript port of percolation-inversion-compiler v0.4.4 public CLI contracts."
+  "TypeScript-compatible port of percolation-inversion-compiler v0.5.0 public CLI contracts."
 ).version(VERSION);
 program.exitOverride();
 addOutputOptions(
@@ -2013,7 +3601,7 @@ addOutputOptions(
   )
 );
 addOutputOptions(
-  program.command("schema").description("Emit canonical Python v0.4.4 JSON Schema.")
+  program.command("schema").description("Emit canonical Python v0.5.0-compatible JSON Schema.")
 ).option("--type <typeName>", "schema type", "Registry").option(
   "--all",
   "emit the schema bundle or copy all schemas when --output-dir is supplied"
@@ -2033,7 +3621,7 @@ addOutputOptions(
   )
 ).action((options) => {
   const registry = parseJsonObject(
-    readFileSync9(options.registry, "utf8"),
+    readFileSync10(options.registry, "utf8"),
     "registry"
   );
   const result = validateByType(registry, "Registry");
@@ -2326,7 +3914,7 @@ addOutputOptions(
     profile: options.profile,
     identityContextPath: options.identityContext
   });
-  const inboxRecord = report.accepted === true ? appendAgentMessage(options.inbox, envelope) : existsSync6(options.inbox) ? readAgentInbox(options.inbox) : { inbox_id: "agent-inbox", messages: [], peers: [], seen_nonces: [] };
+  const inboxRecord = report.accepted === true ? appendAgentMessage(options.inbox, envelope) : existsSync7(options.inbox) ? readAgentInbox(options.inbox) : { inbox_id: "agent-inbox", messages: [], peers: [], seen_nonces: [] };
   const delivery = deliveryReport(
     "send",
     options.inbox,
@@ -2491,6 +4079,146 @@ for (const name of ["benchmark-suite", "dashboard", "observe"]) {
     outputJson(data, options.output);
   });
 }
+var phaseLab = phase.command("lab").description("Run local Phase Ecology Lab diagnostics.");
+addOutputOptions(
+  phaseLab.command("init").requiredOption(
+    "--output-dir <dir>",
+    "Directory for the local Phase Lab store"
+  ).option("--format <format>", "output format", "json")
+).action(
+  (options) => outputJson(initPhaseLabStore(options.outputDir), options.output)
+);
+addOutputOptions(
+  phaseLab.command("ingest").requiredOption("--store <dir>", "Phase Lab store directory").option("--report <path...>", "PIC report JSON. May repeat").option("--packet <path...>", "Packet JSON. May repeat").option("--directory <dir>", "Directory of JSON reports to ingest").option("--format <format>", "output format", "json")
+).action((options) => {
+  if (options.directory) {
+    outputJson(
+      ingestPhaseLabDirectory(options.store, options.directory),
+      options.output
+    );
+    return;
+  }
+  const reports = Array.isArray(options.report) ? options.report : [];
+  const packets = Array.isArray(options.packet) ? options.packet : [];
+  if (reports.length === 0 && packets.length === 0) {
+    throw new Error("provide --report, --packet, or --directory");
+  }
+  outputJson(
+    ingestPhaseLabFiles(options.store, reports, packets),
+    options.output
+  );
+});
+addOutputOptions(
+  phaseLab.command("list-windows").requiredOption("--store <dir>", "Phase Lab store directory").option("--format <format>", "output format", "json")
+).action(
+  (options) => outputJson(listPhaseLabWindows(options.store), options.output)
+);
+addOutputOptions(
+  phaseLab.command("export").requiredOption("--store <dir>", "Phase Lab store directory").requiredOption("--output-dir <dir>", "Export directory").option("--format <format>", "output format", "json")
+).action(
+  (options) => outputJson(
+    exportPhaseLabStore(options.store, options.outputDir),
+    options.output
+  )
+);
+addOutputOptions(
+  phaseLab.command("observe").requiredOption("--store <dir>", "Phase Lab store directory").option(
+    "--window <window>",
+    "latest, previous, all, or window id",
+    "latest"
+  ).option("--format <format>", "output format", "json")
+).action(
+  (options) => outputJson(
+    loadPhaseLabObservation(options.store, options.window).observation,
+    options.output
+  )
+);
+addOutputOptions(
+  phaseLab.command("graph").requiredOption("--store <dir>", "Phase Lab store directory").option("--window <window>", "latest, previous, all, or window id", "all").option("--format <format>", "output format", "json")
+).action(
+  (options) => outputJson(loadPhaseLabGraph(options.store, options.window), options.output)
+);
+addOutputOptions(
+  phaseLab.command("closure").requiredOption("--store <dir>", "Phase Lab store directory").option("--window <window>", "latest, previous, all, or window id", "all").option("--format <format>", "output format", "json")
+).action(
+  (options) => outputJson(
+    detectAutocatalyticClosure(
+      loadPhaseLabGraph(options.store, options.window)
+    ),
+    options.output
+  )
+);
+addOutputOptions(
+  phaseLab.command("executable-paths").requiredOption("--store <dir>", "Phase Lab store directory").option("--window <window>", "latest, previous, all, or window id", "all").option("--format <format>", "output format", "json")
+).action(
+  (options) => outputJson(
+    detectExecutionAvailablePaths(
+      loadPhaseLabGraph(options.store, options.window)
+    ),
+    options.output
+  )
+);
+addOutputOptions(
+  phaseLab.command("threshold-status").requiredOption("--store <dir>", "Phase Lab store directory").requiredOption("--threshold <path>", "ASIProxyThresholdSpec JSON").option("--window <window>", "latest, previous, or window id", "latest").option("--format <format>", "output format", "json")
+).action((options) => {
+  const { observation } = loadPhaseLabObservation(
+    options.store,
+    options.window
+  );
+  outputJson(
+    buildPhaseThresholdStatus(
+      observation,
+      readJsonPath(options.threshold, "threshold")
+    ),
+    options.output
+  );
+});
+addOutputOptions(
+  phaseLab.command("certify").requiredOption("--store <dir>", "Phase Lab store directory").requiredOption("--threshold <path>", "ASIProxyThresholdSpec JSON").option("--window <window>", "latest, previous, or window id", "latest").option("--format <format>", "output format", "json")
+).action((options) => {
+  const { observation, graph } = loadPhaseLabObservation(
+    options.store,
+    options.window
+  );
+  const status = buildPhaseThresholdStatus(
+    observation,
+    readJsonPath(options.threshold, "threshold")
+  );
+  outputJson(
+    buildCollectivePhaseCertificateCandidate(status, graph),
+    options.output
+  );
+});
+addOutputOptions(
+  phaseLab.command("compare-window").requiredOption("--store <dir>", "Phase Lab store directory").requiredOption("--baseline <window>", "previous, latest, or window id").requiredOption("--candidate <window>", "latest or window id").option("--format <format>", "output format", "json")
+).action((options) => {
+  const baseline = loadPhaseLabObservation(
+    options.store,
+    options.baseline
+  ).observation;
+  const candidate = loadPhaseLabObservation(
+    options.store,
+    options.candidate
+  ).observation;
+  outputJson(comparePhaseWindows(baseline, candidate), options.output);
+});
+var phaseClosure = phase.command("closure").description("Find and certify effective graph closure candidates.");
+addOutputOptions(
+  phaseClosure.command("find").requiredOption("--graph <path>", "EffectivePacketGraph JSON").option("--format <format>", "output format", "json")
+).action(
+  (options) => outputJson(
+    detectAutocatalyticClosure(readJsonPath(options.graph, "effective graph")),
+    options.output
+  )
+);
+addOutputOptions(
+  phaseClosure.command("certify").requiredOption("--graph <path>", "EffectivePacketGraph JSON").option("--format <format>", "output format", "json")
+).action(
+  (options) => outputJson(
+    detectAutocatalyticClosure(readJsonPath(options.graph, "effective graph")).certificate_candidate,
+    options.output
+  )
+);
 var runtime = program.command("runtime").description("Run bounded local runtime loops.");
 addOutputOptions(
   addProfile(
@@ -2547,6 +4275,55 @@ compile.action(
     options.output
   )
 );
+var bit = program.command("bit").description("Run BIT bottleneck inversion diagnostics.");
+addOutputOptions(
+  bit.command("diagnose").requiredOption("--graph <path>", "EffectivePacketGraph JSON")
+).action(
+  (options) => outputJson(
+    diagnoseBottlenecks(readJsonPath(options.graph, "effective graph")),
+    options.output
+  )
+);
+addOutputOptions(
+  bit.command("invert").requiredOption("--bottlenecks <path>", "BottleneckInversionReport JSON")
+).action(
+  (options) => outputJson(
+    invertBottlenecks(readJsonPath(options.bottlenecks, "bottlenecks")),
+    options.output
+  )
+);
+addOutputOptions(
+  bit.command("mec").requiredOption("--bottleneck <id>", "Bottleneck id").option("--bottlenecks <path>", "Optional BottleneckInversionReport JSON")
+).action(
+  (options) => outputJson(
+    {
+      minimal_enabling_conditions: buildMinimalEnablingConditions(
+        options.bottleneck,
+        options.bottlenecks ? readJsonPath(options.bottlenecks, "bottlenecks") : void 0
+      )
+    },
+    options.output
+  )
+);
+addOutputOptions(
+  bit.command("certificate").requiredOption("--candidate <path>", "BottleneckInversionCandidate JSON")
+).action(
+  (options) => outputJson(
+    buildInversionCertificate(readJsonPath(options.candidate, "candidate")),
+    options.output
+  )
+);
+addOutputOptions(
+  bit.command("compare-baseline").requiredOption("--baseline <path>", "PhaseWindowObservation JSON").requiredOption("--candidate <path>", "PhaseWindowObservation JSON")
+).action(
+  (options) => outputJson(
+    compareBottleneckBaseline(
+      readJsonPath(options.baseline, "baseline observation"),
+      readJsonPath(options.candidate, "candidate observation")
+    ),
+    options.output
+  )
+);
 var sqot = program.command("sqot");
 addOutputOptions(
   addProfile(sqot.command("schedule").option("--packets <path>"))
@@ -2559,10 +4336,107 @@ addOutputOptions(sqot.command("audit").option("--source <path>")).action(
     options.output
   )
 );
+addOutputOptions(
+  sqot.command("diagnose-queue").requiredOption("--graph <path>", "EffectivePacketGraph JSON").option(
+    "--attention-budget <number>",
+    "Finite diagnostic attention budget",
+    "1"
+  )
+).action(
+  (options) => outputJson(
+    diagnoseQueueOccupation(
+      readJsonPath(options.graph, "effective graph"),
+      Number(options.attentionBudget ?? 1)
+    ),
+    options.output
+  )
+);
+addOutputOptions(
+  sqot.command("salience-obstruction").requiredOption("--graph <path>", "EffectivePacketGraph JSON")
+).action(
+  (options) => outputJson(
+    diagnoseSalienceObstruction(readJsonPath(options.graph, "effective graph")),
+    options.output
+  )
+);
+addOutputOptions(
+  sqot.command("rebalance").requiredOption("--graph <path>", "EffectivePacketGraph JSON")
+).action(
+  (options) => outputJson(
+    buildQueueRebalancePlan(readJsonPath(options.graph, "effective graph")),
+    options.output
+  )
+);
+addOutputOptions(
+  sqot.command("quarantine").requiredOption("--graph <path>", "EffectivePacketGraph JSON")
+).action(
+  (options) => outputJson(
+    buildPacketQuarantineDecisions(
+      readJsonPath(options.graph, "effective graph")
+    ),
+    options.output
+  )
+);
+addOutputOptions(
+  sqot.command("reserve-check").requiredOption("--graph <path>", "EffectivePacketGraph JSON").option(
+    "--attention-budget <number>",
+    "Finite diagnostic attention budget",
+    "1"
+  )
+).action(
+  (options) => outputJson(
+    checkDiagnosticReserve(
+      readJsonPath(options.graph, "effective graph"),
+      Number(options.attentionBudget ?? 1)
+    ),
+    options.output
+  )
+);
 var alt = program.command("alt");
 addOutputOptions(alt.command("admit").option("--packet <path>")).action(
   (options) => outputJson(altAdmit(options.packet ?? "alt-packet:demo"), options.output)
 );
+addOutputOptions(
+  alt.command("ecpt-lift").requiredOption("--packets <path...>", "ALT packet/report JSON. May repeat").requiredOption("--graph <path>", "EffectivePacketGraph JSON")
+).action(
+  (options) => outputJson(
+    verifyAltEcptLift(
+      readJsonPaths(options.packets, "ALT packet"),
+      readJsonPath(options.graph, "effective graph")
+    ),
+    options.output
+  )
+);
+addOutputOptions(
+  alt.command("receiver-lift").requiredOption("--packet <path>", "ALT packet/report JSON").requiredOption("--receiver-context <path>", "Receiver context JSON")
+).action(
+  (options) => outputJson(
+    verifyReceiverLift(
+      readJsonPath(options.packet, "ALT packet"),
+      readJsonPath(options.receiverContext, "receiver context")
+    ),
+    options.output
+  )
+);
+addOutputOptions(
+  alt.command("liquidity-to-paths").requiredOption("--packet <path>", "ALT packet/report JSON").requiredOption("--graph <path>", "EffectivePacketGraph JSON")
+).action(
+  (options) => outputJson(
+    mapLiquidityToPaths(
+      readJsonPath(options.packet, "ALT packet"),
+      readJsonPath(options.graph, "effective graph")
+    ),
+    options.output
+  )
+);
+addOutputOptions(
+  alt.command("capital-impact").requiredOption("--reports <path...>", "ALT report JSON. May repeat")
+).action(
+  (options) => outputJson(
+    estimateCapitalImpact(readJsonPaths(options.reports, "ALT report")),
+    options.output
+  )
+);
 for (const name of [
   "audit",
   "tokenize",
@@ -2582,6 +4456,31 @@ for (const name of [
     (options) => outputJson(diagnostic(`alt:${name}`), options.output)
   );
 }
+var trc = program.command("trc").description("Adapt traces into typed TRC diagnostic data.");
+addOutputOptions(
+  trc.command("trace-adapter").requiredOption("--input <path>", "Trace JSON")
+).action(
+  (options) => outputJson(
+    adaptTrcTrace(readJsonPath(options.input, "trace input")),
+    options.output
+  )
+);
+addOutputOptions(
+  trc.command("tool-trace").requiredOption("--events <path>", "JSON tool events")
+).action(
+  (options) => outputJson(
+    adaptToolTrace(readJsonPath(options.events, "tool events")),
+    options.output
+  )
+);
+addOutputOptions(
+  trc.command("action-boundary").requiredOption("--report <path>", "Runtime report JSON")
+).action(
+  (options) => outputJson(
+    buildActionBoundaryReport(readJsonPath(options.report, "runtime report")),
+    options.output
+  )
+);
 var ecology = program.command("ecology");
 addOutputOptions(
   ecology.command("ingest").option("--source <source>").option("--kind <kind>", "kind", "local")
@@ -2600,6 +4499,24 @@ addOutputOptions(
 ).action(
   (options) => outputJson(ecologyPolicy(options.profile), options.output)
 );
+addOutputOptions(
+  ecology.command("effective-graph").requiredOption("--reports <path...>", "PIC report JSON. May repeat")
+).action(
+  (options) => outputJson(
+    buildEffectivePacketGraph(readJsonPaths(options.reports, "ecology report")),
+    options.output
+  )
+);
+addOutputOptions(
+  ecology.command("execution-available-paths").requiredOption("--graph <path>", "EffectivePacketGraph JSON")
+).action(
+  (options) => outputJson(
+    detectExecutionAvailablePaths(
+      readJsonPath(options.graph, "effective graph")
+    ),
+    options.output
+  )
+);
 for (const name of [
   "ingest-general",
   "discover-web",
@@ -2624,7 +4541,7 @@ addOutputOptions(
   identity.command("verify").requiredOption("--identity <path>")
 ).action((options) => {
   const data = parseJsonObject(
-    readFileSync9(options.identity, "utf8"),
+    readFileSync10(options.identity, "utf8"),
     "identity"
   );
   const validation = validateByType(data, "CryptographicAgentIdentity");
@@ -2661,7 +4578,7 @@ addOutputOptions(
   identity.command("verify-attestation").requiredOption("--attestation <path>").requiredOption("--identities <path>")
 ).action((options) => {
   const attestation = parseJsonObject(
-    readFileSync9(options.attestation, "utf8"),
+    readFileSync10(options.attestation, "utf8"),
     "attestation"
   );
   const validation = validateByType(attestation, "AgentIdentityAttestation");
@@ -2679,7 +4596,7 @@ addOutputOptions(
   identity.command("sybil-check").requiredOption("--population <path>")
 ).action((options) => {
   const population = parseJsonObject(
-    readFileSync9(options.population, "utf8"),
+    readFileSync10(options.population, "utf8"),
     "population"
   );
   const validation = validateByType(population, "AgentPopulationState");
@@ -2717,7 +4634,7 @@ addOutputOptions(
   )
 ).action((options) => {
   const population = parseJsonObject(
-    readFileSync9(options.population, "utf8"),
+    readFileSync10(options.population, "utf8"),
     "population"
   );
   const validation = validateByType(population, "AgentPopulationState");
@@ -2866,32 +4783,58 @@ addOutputOptions(
     options.output
   )
 );
+function nodeOnlyDemoCommands(demoDir = "pic-demo") {
+  return [
+    `pic-ts runtime step --state ${demoDir}/runtime_state.json --input ${demoDir}/runtime_step_input.json --output ${demoDir}/runtime_step_report.generated.json`,
+    `pic-ts packet export --report ${demoDir}/runtime_step_report.generated.json --output ${demoDir}/packet.json`,
+    `pic-ts packet inspect --packet ${demoDir}/packet.json`,
+    `pic-ts phase lab init --output-dir ${demoDir}/phase-lab`,
+    `pic-ts phase lab ingest --store ${demoDir}/phase-lab --report ${demoDir}/runtime_step_report.generated.json`,
+    `pic-ts phase lab observe --store ${demoDir}/phase-lab --window latest`,
+    `pic-ts phase lab graph --store ${demoDir}/phase-lab`,
+    `pic-ts phase lab closure --store ${demoDir}/phase-lab`,
+    `pic-ts phase lab executable-paths --store ${demoDir}/phase-lab`,
+    `pic-ts phase lab certify --store ${demoDir}/phase-lab --threshold ${demoDir}/asi_proxy_development.json`,
+    `pic-ts phase plan --request ${demoDir}/asi_proxy_phase_request.json --compact`,
+    'pic-ts agent accelerate --compact --text "Candidate packet: preserve residuals." --profile development'
+  ];
+}
 var demo = program.command("demo");
 addOutputOptions(addProfile(demo.command("installed-smoke"))).action(
-  (options) => outputJson(
-    { ...pythonCliFixture("demo_installed_smoke"), profile: options.profile },
-    options.output
-  )
+  (options) => {
+    const report = {
+      ...pythonCliFixture("demo_installed_smoke"),
+      profile: options.profile,
+      recommended_next_commands: nodeOnlyDemoCommands(),
+      settled: false
+    };
+    outputJson(report, options.output);
+  }
 );
 addOutputOptions(
   demo.command("bootstrap").requiredOption("--output-dir <dir>").option("--overwrite", "overwrite files")
 ).action((options) => {
-  mkdirSync4(options.outputDir, { recursive: true });
-  const demoDir = join4(fixtureRoot(), "python_v044_demo");
+  mkdirSync5(options.outputDir, { recursive: true });
+  const demoDir = join5(fixtureRoot(), "python_v044_demo");
   const copied = [];
-  for (const file of readdirSync2(demoDir).filter(
+  for (const file of readdirSync3(demoDir).filter(
     (name) => [".json", ".txt"].some((suffix) => name.endsWith(suffix))
   )) {
-    cpSync2(join4(demoDir, file), join4(options.outputDir, file));
+    cpSync2(join5(demoDir, file), join5(options.outputDir, file));
     copied.push(file);
   }
+  cpSync2(
+    join5(packageRoot(), "examples", "thresholds", "asi_proxy_development.json"),
+    join5(options.outputDir, "asi_proxy_development.json")
+  );
+  copied.push("asi_proxy_development.json");
   for (const [file, fixture] of [
     ["agent_check_report.json", "agent_check_full"],
     ["phase_acceleration_plan.json", "phase_plan_full"],
     ["phase_acceleration_plan.compact.json", "phase_plan_compact"]
   ]) {
-    writeFileSync4(
-      join4(options.outputDir, file),
+    writeFileSync5(
+      join5(options.outputDir, file),
       stableStringify(pythonCliFixture(fixture)),
       "utf8"
     );
@@ -2902,6 +4845,7 @@ addOutputOptions(
       accepted: true,
       output_dir: options.outputDir,
       files: copied.sort(),
+      recommended_next_commands: nodeOnlyDemoCommands(options.outputDir),
       settled: false
     },
     options.output