percolation-inversion-compiler-ts 0.4.4

package/dist/index.js

@@ -0,0 +1,983 @@
+// src/core/json.ts
+function sortJson(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortJson(item));
+  }
+  if (value && typeof value === "object") {
+    const input = value;
+    const output = {};
+    for (const key of Object.keys(input).sort()) {
+      const child = input[key];
+      if (child !== void 0) {
+        output[key] = sortJson(child);
+      }
+    }
+    return output;
+  }
+  return value;
+}
+function stableStringify(value) {
+  return `${JSON.stringify(sortJson(value), null, 2)}
+`;
+}
+function lfNormalize(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function parseJsonObject(text, label = "JSON") {
+  const parsed = JSON.parse(text);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${label} must be a JSON object`);
+  }
+  return parsed;
+}
+function dedupeSorted(values) {
+  return [
+    ...new Set([...values].filter((item) => Boolean(item)))
+  ].sort();
+}
+
+// src/core/ledger.ts
+function residualLedger(name, value = 1, description) {
+  return {
+    coordinates: {
+      [name]: {
+        name,
+        value,
+        unit: "dimensionless",
+        kind: "residual",
+        description: description ?? null,
+        evidence_status: "declared",
+        evidence_refs: [],
+        known: true
+      }
+    }
+  };
+}
+function summarizeLedger(ledger) {
+  const summary = {};
+  if (!ledger) {
+    return summary;
+  }
+  for (const coordinate of Object.values(ledger.coordinates ?? {})) {
+    const kind = coordinate.kind ?? "residual";
+    summary[kind] = (summary[kind] ?? 0) + Number(coordinate.value ?? 0);
+  }
+  return Object.fromEntries(
+    Object.entries(summary).sort(([a], [b]) => a.localeCompare(b))
+  );
+}
+
+// src/io/fixtures.ts
+import { readFileSync } from "fs";
+import { join as join2, normalize, sep } from "path";
+
+// src/io/paths.ts
+import { existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+function packageRoot() {
+  let current = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 8; i += 1) {
+    if (existsSync(join(current, "package.json")) && existsSync(join(current, "schemas"))) {
+      return current;
+    }
+    const next = dirname(current);
+    if (next === current) {
+      break;
+    }
+    current = next;
+  }
+  return resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+}
+function schemaDir() {
+  return join(packageRoot(), "schemas");
+}
+function fixtureRoot() {
+  return join(packageRoot(), "fixtures");
+}
+
+// src/io/fixtures.ts
+function safeFixturePath(...parts) {
+  const root = normalize(fixtureRoot());
+  const normalized = normalize(join2(root, ...parts));
+  if (normalized !== root && !normalized.startsWith(`${root}${sep}`)) {
+    throw new Error("fixture path escapes package fixtures");
+  }
+  return normalized;
+}
+function fixtureText(namespace, file) {
+  if (namespace.includes("..") || file.includes("..")) {
+    throw new Error("fixture path must not contain parent traversal");
+  }
+  return readFileSync(safeFixturePath(namespace, file), "utf8");
+}
+function fixtureJsonFrom(namespace, file) {
+  return parseJsonObject(fixtureText(namespace, file), `${namespace}/${file}`);
+}
+function pythonCliFixture(name) {
+  if (!/^[a-z0-9_]+$/.test(name)) {
+    throw new Error(
+      `invalid Python v0.4.4 CLI fixture ${JSON.stringify(name)}`
+    );
+  }
+  return fixtureJsonFrom("python_v044_cli", `${name}.json`);
+}
+
+// src/phase/index.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
+
+// src/io/schema.ts
+import {
+  cpSync,
+  existsSync as existsSync2,
+  mkdirSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  writeFileSync
+} from "fs";
+import { basename, join as join3 } from "path";
+import Ajv2020Module from "ajv/dist/2020.js";
+var PUBLIC_SCHEMA_NAME = /^[A-Za-z][A-Za-z0-9]*$/;
+function assertSchemaTypeName(typeName) {
+  if (!PUBLIC_SCHEMA_NAME.test(typeName)) {
+    throw new Error(`unknown schema type ${JSON.stringify(typeName)}`);
+  }
+}
+function schemaPath(typeName) {
+  assertSchemaTypeName(typeName);
+  return join3(schemaDir(), `${typeName}.schema.json`);
+}
+function schemaNames() {
+  return readdirSync(schemaDir()).filter(
+    (name) => name.endsWith(".schema.json") && name !== "bundle.schema.json"
+  ).map((name) => name.slice(0, -".schema.json".length)).sort();
+}
+function schemaByType(typeName = "Registry") {
+  const path = schemaPath(typeName);
+  if (!existsSync2(path)) {
+    throw new Error(`unknown schema type ${JSON.stringify(typeName)}`);
+  }
+  return parseJsonObject(readFileSync2(path, "utf8"), `${typeName} schema`);
+}
+function schemaBundle() {
+  const bundlePath = join3(schemaDir(), "bundle.schema.json");
+  if (existsSync2(bundlePath)) {
+    const bundle = parseJsonObject(
+      readFileSync2(bundlePath, "utf8"),
+      "schema bundle"
+    );
+    if (bundle.bundle_id && bundle.schemas && typeof bundle.schemas === "object" && !Array.isArray(bundle.schemas)) {
+      return bundle;
+    }
+  }
+  const schemas = {};
+  for (const name of schemaNames()) {
+    schemas[name] = schemaByType(name);
+  }
+  return {
+    bundle_id: "percolation-inversion-compiler-portability",
+    schemas
+  };
+}
+function validateData(data, schema) {
+  const Ajv2020 = Ajv2020Module;
+  const ajv = new Ajv2020({ allErrors: true, strict: false });
+  const validate = ajv.compile(schema);
+  const valid = Boolean(validate(data));
+  return {
+    valid,
+    errors: valid ? [] : (validate.errors ?? []).map(
+      (error) => `${error.instancePath || "/"} ${error.message ?? "is invalid"}`
+    )
+  };
+}
+function validateByType(data, typeName) {
+  return validateData(data, schemaByType(typeName));
+}
+function writeAllSchemas(outputDir) {
+  mkdirSync(outputDir, { recursive: true });
+  const written = [];
+  const files = [
+    ...schemaNames().map((name) => `${name}.schema.json`),
+    "bundle.schema.json",
+    "schema-digest.json"
+  ];
+  for (const file of files) {
+    const source = join3(schemaDir(), file);
+    if (!existsSync2(source)) {
+      continue;
+    }
+    const target = join3(outputDir, file);
+    cpSync(source, target);
+    written.push(basename(target));
+  }
+  return written.sort();
+}
+
+// src/io/identity.ts
+function nonEmptyStringArray(value) {
+  return Array.isArray(value) && value.some((item) => typeof item === "string" && item.length > 0);
+}
+function runtimeIdentityContextAccepted(data) {
+  return validateByType(data, "RuntimeIdentityContext").valid && data.accepted === true && nonEmptyStringArray(data.accepted_agent_ids) && nonEmptyStringArray(data.accepted_public_key_ids);
+}
+
+// src/runtime/index.ts
+import { readFileSync as readFileSync3 } from "fs";
+function clone(value) {
+  return structuredClone(value);
+}
+function minimalRuntimeState() {
+  return {
+    state_id: "runtime-state:minimal",
+    profile: "development",
+    candidate_registry: { packets: [], edges: [] },
+    residual_ledger: residualLedger(
+      "runtime:minimal-state",
+      1,
+      "minimal state carries unresolved verifier debt"
+    ),
+    accepted_agent_ids: [],
+    accepted_public_key_ids: [],
+    identity_mode: "development"
+  };
+}
+function minimalRuntimeStepInput(agentOutput = "Candidate packet: preserve residuals.") {
+  return {
+    input_id: "runtime-step-input:minimal",
+    agent_output: agentOutput,
+    allow_live_connectors: true,
+    candidate_only: true
+  };
+}
+function buildRuntimeStep(options = {}) {
+  const report = clone(pythonCliFixture("runtime_step_demo"));
+  const profile = options.profile ?? "development";
+  const reasons = new Set(
+    Array.isArray(report.reasons) ? report.reasons.map(String) : []
+  );
+  if (options.agentOutput) {
+    report.agent_output_digest = `sha256:${Buffer.from(options.agentOutput, "utf8").toString("hex").slice(0, 16)}`;
+  }
+  if (options.statePath) {
+    const state = parseJsonObject(
+      readFileSync3(options.statePath, "utf8"),
+      "runtime state"
+    );
+    const validation = validateByType(state, "RuntimeState");
+    if (!validation.valid) {
+      throw new Error(
+        `runtime state schema-invalid: ${validation.errors.join("; ")}`
+      );
+    }
+  }
+  if (options.inputPath) {
+    const input = parseJsonObject(
+      readFileSync3(options.inputPath, "utf8"),
+      "runtime input"
+    );
+    const validation = validateByType(input, "RuntimeStepInput");
+    if (!validation.valid) {
+      throw new Error(
+        `runtime input schema-invalid: ${validation.errors.join("; ")}`
+      );
+    }
+    if (typeof input.allow_live_connectors === "boolean") {
+      report.allow_live_connectors = input.allow_live_connectors;
+    }
+  }
+  if (typeof options.allowLiveConnectors === "boolean") {
+    report.allow_live_connectors = options.allowLiveConnectors;
+  }
+  if (options.identityContextPath) {
+    const identity = parseJsonObject(
+      readFileSync3(options.identityContextPath, "utf8"),
+      "identity context"
+    );
+    const validation = validateByType(identity, "RuntimeIdentityContext");
+    const accepted = runtimeIdentityContextAccepted(identity);
+    report.identity_context_accepted = accepted;
+    report.identity_verified = accepted;
+    if (!accepted) {
+      reasons.add("identity context is missing or not accepted");
+      report.operationally_usable = false;
+    }
+  }
+  if (profile === "production" || profile === "adversarial") {
+    if (!options.identityContextPath) {
+      reasons.add(
+        "production/adversarial identity context is missing or not accepted"
+      );
+      report.operationally_usable = false;
+      report.identity_verified = false;
+    }
+  }
+  report.accepted = true;
+  report.finite_checks_passed = true;
+  report.settled = false;
+  report.reasons = [...reasons].sort();
+  return report;
+}
+function runtimeHealth(profile = "development") {
+  return {
+    report_id: "runtime-health",
+    profile,
+    accepted: true,
+    operationally_usable: profile === "development",
+    settled: false,
+    checks: {
+      command_execution_allowed: false,
+      background_crawling_allowed: false,
+      hidden_promotion_allowed: false,
+      residual_ledgers_preserved: true
+    },
+    reasons: profile === "development" ? [] : [
+      "production profile requires explicit identity and provenance context"
+    ]
+  };
+}
+
+// src/phase/index.ts
+function clone2(value) {
+  return structuredClone(value);
+}
+var phaseSchemaRefs = pythonCliFixture("phase_plan_compact").schema_refs ?? [
+  "PhaseAccelerationRequest",
+  "PhaseAccelerationPlan",
+  "PhaseGapVector",
+  "PhaseComponentGap",
+  "BottleneckCandidate",
+  "SafePhaseAction"
+];
+function phaseAccelerationSafetyInvariants() {
+  const fixture = pythonCliFixture("phase_plan_compact");
+  if (Array.isArray(fixture.safety_invariants)) {
+    return fixture.safety_invariants.map(String);
+  }
+  return [
+    "phase acceleration planning is recommendation-only and does not execute actions",
+    "raw external candidate volume cannot improve Psi, BR, AC, or settled status",
+    "candidate packets, agent messages, and proxy-only ALT reports remain candidates",
+    "settled remains false unless scoped finite verifier rules discharge all obligations",
+    "residual ledgers and missing obligations must be preserved into downstream loops",
+    "ASI-proxy phase is protocol-relative workflow coordination, not real ASI proof",
+    "no physical, simulator, oracle, legal, or policy outcome is proven by this report",
+    "no hidden promotion from accepted or workflow_usable to settled"
+  ];
+}
+function identityContextAccepted(path) {
+  if (!path || !existsSync3(path)) {
+    return false;
+  }
+  try {
+    const data = parseJsonObject(
+      readFileSync4(path, "utf8"),
+      "identity context"
+    );
+    return runtimeIdentityContextAccepted(data);
+  } catch {
+    return false;
+  }
+}
+function runtimeReportIdentityAccepted(report) {
+  if (!report) {
+    return false;
+  }
+  const identity = report.identity_context;
+  if (!identity || typeof identity !== "object" || Array.isArray(identity)) {
+    return false;
+  }
+  const data = identity;
+  return runtimeIdentityContextAccepted(data);
+}
+function objectList(value) {
+  return Array.isArray(value) ? value.filter((item) => item && typeof item === "object") : [];
+}
+function ensureActionBoundary(plan) {
+  for (const action of objectList(plan.recommended_actions)) {
+    action.execution_authority_granted = false;
+    action.settled = false;
+  }
+}
+function buildPhaseAccelerationPlan(request = {}) {
+  const plan = clone2(pythonCliFixture("phase_plan_full"));
+  const profile = request.profile ?? "development";
+  const hasDynamicRuntimeInput = Boolean(
+    request.agent_output || request.profile && request.profile !== "development" || request.allow_live_connectors === false || request.identity_context_path
+  );
+  const runtimeReport = request.runtime_report ?? (hasDynamicRuntimeInput ? buildRuntimeStep({
+    profile,
+    agentOutput: request.agent_output,
+    allowLiveConnectors: request.allow_live_connectors,
+    identityContextPath: request.identity_context_path
+  }) : plan.runtime_report);
+  const cannotPromote = new Set(
+    Array.isArray(plan.cannot_promote_because) ? plan.cannot_promote_because.map(String) : []
+  );
+  const candidateOnly = new Set(
+    Array.isArray(plan.candidate_only_reasons) ? plan.candidate_only_reasons.map(String) : []
+  );
+  const settledBlockers = new Set(
+    Array.isArray(plan.settled_blockers) ? plan.settled_blockers.map(String) : []
+  );
+  const reasons = new Set(
+    Array.isArray(plan.reasons) ? plan.reasons.map(String) : []
+  );
+  cannotPromote.add("missing obligations remain");
+  settledBlockers.add(
+    "phase planner is recommendation-only and cannot settle claims"
+  );
+  if ((request.general_intake_bridge_reports ?? []).some(
+    (report) => report.candidate_only !== false
+  )) {
+    candidateOnly.add(
+      "candidate-only external volume cannot reduce phase gaps"
+    );
+  }
+  if ((request.alt_admission_decisions ?? []).some(
+    (decision) => Array.isArray(decision.missing_obligations) && decision.missing_obligations.length > 0
+  )) {
+    candidateOnly.add(
+      "ALT admission is candidate-only until missing obligations are discharged"
+    );
+  }
+  const identityRequired = profile === "production" || profile === "adversarial";
+  const identityAccepted = identityContextAccepted(request.identity_context_path) || runtimeReportIdentityAccepted(runtimeReport);
+  if (identityRequired && !identityAccepted) {
+    cannotPromote.add(
+      "production/adversarial identity context is missing or not accepted"
+    );
+    settledBlockers.add(
+      "production identity context is required before operational promotion"
+    );
+  }
+  plan.plan_id = `phase-acceleration-plan:${request.request_id ?? "phase-acceleration"}`;
+  plan.request_id = request.request_id ?? "phase-acceleration";
+  plan.profile = profile;
+  plan.report_mode = request.compact ? "compact" : "full";
+  plan.accepted = true;
+  plan.workflow_usable = true;
+  plan.finite_checks_passed = plan.finite_checks_passed ?? true;
+  plan.operationally_usable = !(identityRequired && !identityAccepted);
+  plan.settled = false;
+  plan.status = cannotPromote.size > 0 || candidateOnly.size > 0 ? "diagnostic" : "provisional";
+  plan.runtime_report = request.compact ? void 0 : runtimeReport;
+  plan.cannot_promote_because = [...cannotPromote].sort();
+  plan.candidate_only_reasons = [...candidateOnly].sort();
+  plan.settled_blockers = [...settledBlockers].sort();
+  plan.reasons = dedupeSorted([...reasons, ...cannotPromote, ...candidateOnly]);
+  plan.safety_invariants = phaseAccelerationSafetyInvariants();
+  plan.schema_refs = phaseSchemaRefs;
+  plan.safe_commands = dedupeSorted([
+    ...Array.isArray(plan.safe_commands) ? plan.safe_commands.map(String) : []
+  ]);
+  plan.sdk_calls = dedupeSorted([
+    ...Array.isArray(plan.sdk_calls) ? plan.sdk_calls.map(String) : []
+  ]);
+  ensureActionBoundary(plan);
+  return plan;
+}
+function phaseAccelerationCompactPayload(plan) {
+  return {
+    plan_id: plan.plan_id,
+    request_id: plan.request_id,
+    profile: plan.profile,
+    report_mode: "compact",
+    accepted: plan.accepted,
+    workflow_usable: plan.workflow_usable,
+    finite_checks_passed: plan.finite_checks_passed ?? true,
+    operationally_usable: plan.operationally_usable,
+    settled: false,
+    status: plan.status ?? "diagnostic",
+    phase_gap_vector: plan.phase_gap_vector,
+    top_bottlenecks: plan.top_bottlenecks ?? (Array.isArray(plan.bottlenecks) ? plan.bottlenecks.slice(0, 5) : []),
+    safe_commands: plan.safe_commands ?? [],
+    sdk_calls: plan.sdk_calls ?? [],
+    schema_refs: plan.schema_refs ?? phaseSchemaRefs,
+    cannot_promote_because: plan.cannot_promote_because ?? [],
+    candidate_only_reasons: plan.candidate_only_reasons ?? [],
+    settled_blockers: plan.settled_blockers ?? [],
+    residual_summary: plan.residual_summary ?? {},
+    missing_obligations: plan.missing_obligations ?? [],
+    safety_invariants: plan.safety_invariants ?? phaseAccelerationSafetyInvariants(),
+    reasons: plan.reasons ?? []
+  };
+}
+function phaseAccelerationRunbook(profile = "development") {
+  const runbook = clone2(pythonCliFixture("phase_runbook"));
+  runbook.profile = profile;
+  return runbook;
+}
+function buildPhaseAccelerationBenchmark(profile = "development") {
+  const report = clone2(pythonCliFixture("phase_benchmark"));
+  report.profile = profile;
+  report.accepted = true;
+  report.workflow_usable = true;
+  report.operationally_usable = true;
+  report.settled = false;
+  report.invariant_checks = {
+    candidate_only_volume_does_not_reduce_gap: true,
+    planner_does_not_execute_commands: true,
+    residuals_visible: true,
+    settled_not_promoted: true
+  };
+  report.safety_invariants = phaseAccelerationSafetyInvariants();
+  return report;
+}
+
+// src/agent/index.ts
+function clone3(value) {
+  return structuredClone(value);
+}
+function agentSafetyInvariants() {
+  const fixture = pythonCliFixture("agent_check_compact");
+  if (Array.isArray(fixture.safety_invariants)) {
+    return fixture.safety_invariants.map(String);
+  }
+  return [
+    "accepted is not settled",
+    "workflow_usable is not settled",
+    "safe_commands are inspection guidance and are not executed by PIC",
+    "residual ledgers and missing obligations are preserved",
+    "no hidden promotion from accepted or workflow_usable to settled",
+    "default-live explicit sources remain candidate-only until verified"
+  ];
+}
+function runAgentIntake(request = {}) {
+  const report = clone3(pythonCliFixture("agent_intake"));
+  const hasDynamicInput = Boolean(
+    request.agent_output || request.profile && request.profile !== "development" || request.allow_live_connectors === false || request.identity_context_path
+  );
+  const runtime = hasDynamicInput ? buildRuntimeStep({
+    profile: request.profile,
+    agentOutput: request.agent_output,
+    allowLiveConnectors: request.allow_live_connectors,
+    identityContextPath: request.identity_context_path
+  }) : report.runtime_report;
+  report.report_id = `agent-intake:${request.request_id ?? "agent-intake"}:agent-intake-step`;
+  report.profile = request.profile ?? "development";
+  report.runtime_report = runtime;
+  report.accepted = runtime.accepted;
+  report.operationally_usable = runtime.operationally_usable;
+  report.settled = false;
+  report.residual_summary = summarizeLedger(runtime.residual_ledger);
+  report.recommended_next_commands = [
+    "Inspect runtime_report.residual_ledger and runtime_report.missing_obligations.",
+    "Inspect runtime_report.route_execution_requests before route execution.",
+    "Review runtime_report.agent_tasks; do not execute arbitrary commands.",
+    "Run another runtime step after new evidence or action results are available."
+  ];
+  report.reasons = Array.isArray(runtime.reasons) ? runtime.reasons : [];
+  return report;
+}
+function runAgentCheck(request = {}, compact = false) {
+  const report = clone3(
+    compact ? pythonCliFixture("agent_check_compact") : pythonCliFixture("agent_check_full")
+  );
+  const intake = runAgentIntake(request);
+  const runtime = intake.runtime_report;
+  const unresolved = dedupeSorted([
+    ...runtime.missing_obligations ?? []
+  ]);
+  const reasons = dedupeSorted([
+    ...intake.reasons ?? [],
+    "unresolved obligations remain; use workflow_usable for routing only"
+  ]);
+  report.report_id = `agent-check:${request.request_id ?? "agent-intake"}`;
+  report.profile = request.profile ?? "development";
+  report.report_mode = compact ? "compact" : "full";
+  report.compact = compact;
+  report.practical_entrypoint = compact ? "pic agent check --compact" : "pic agent check";
+  report.intake_report = intake;
+  report.unresolved_obligations = unresolved;
+  report.residual_summary = intake.residual_summary;
+  report.workflow_usable = true;
+  report.accepted = true;
+  report.operationally_usable = Boolean(intake.operationally_usable);
+  report.settled = false;
+  report.reasons = reasons;
+  report.safety_invariants = agentSafetyInvariants();
+  return compact ? agentCheckCompactPayload(report) : report;
+}
+function agentCheckCompactPayload(report) {
+  return {
+    report_id: report.report_id,
+    profile: report.profile,
+    report_mode: "compact",
+    accepted: report.accepted,
+    workflow_usable: report.workflow_usable,
+    operationally_usable: report.operationally_usable,
+    settled: false,
+    checked_outputs: report.checked_outputs ?? {
+      agent_tasks: "present",
+      input: "accepted",
+      promotion: "diagnostic",
+      residual_ledger: "preserved",
+      route_requests: "present",
+      salience_schedule: "accepted"
+    },
+    unresolved_obligations: report.unresolved_obligations ?? [],
+    residual_summary: report.residual_summary ?? {},
+    next_safe_actions: report.next_safe_actions ?? [
+      "Inspect unresolved_obligations before reusing the output.",
+      "Preserve residual_summary in downstream logs.",
+      "Route verifier requests before promoting candidates to reusable work."
+    ],
+    schema_refs: report.schema_refs ?? [
+      "AgentCheckReport",
+      "AgentIntakeReport",
+      "RuntimeStepReport"
+    ],
+    runbook_steps: report.runbook_steps ?? agentRunbookSteps(String(report.profile ?? "development")),
+    safety_invariants: report.safety_invariants ?? agentSafetyInvariants(),
+    reasons: report.reasons ?? []
+  };
+}
+function accelerateAgentPhase(request = {}, compact = false) {
+  const plan = buildPhaseAccelerationPlan({
+    request_id: `agent-accelerate:${request.request_id ?? "agent-intake"}`,
+    profile: request.profile ?? "development",
+    compact,
+    agent_output: request.agent_output,
+    allow_live_connectors: request.allow_live_connectors,
+    identity_context_path: request.identity_context_path
+  });
+  return compact ? phaseAccelerationCompactPayload(plan) : plan;
+}
+function agentRunbookSteps(profile = "development") {
+  return [
+    `pic agent check --compact --profile ${profile}`,
+    "Inspect accepted, workflow_usable, operationally_usable, settled.",
+    "Inspect residual_summary and unresolved_obligations.",
+    "Run verifier routes before packet promotion.",
+    "Keep settled=false unless scoped finite obligations are discharged."
+  ];
+}
+
+// src/trc/index.ts
+import { readFileSync as readFileSync5 } from "fs";
+function compileTrc(options = {}) {
+  let records = [];
+  const reasons = [];
+  if (options.recordsPath) {
+    const parsed = JSON.parse(
+      readFileSync5(options.recordsPath, "utf8")
+    );
+    records = Array.isArray(parsed) ? parsed : Array.isArray(parsed.records) ? parsed.records : [];
+  }
+  const invalidMainTrace = records.some((record) => {
+    const obj = record;
+    return obj.stratum === "main" && !obj.trace_id && !obj.trace;
+  });
+  if (invalidMainTrace) {
+    reasons.push(
+      "main frontier record lacks accepted executable trace normal form"
+    );
+  }
+  const accepted = !invalidMainTrace;
+  return {
+    result_id: "trc-compile-result",
+    accepted,
+    operationally_usable: accepted && !invalidMainTrace,
+    settled: false,
+    main_frontier_count: invalidMainTrace ? 0 : records.length,
+    diagnostic_count: invalidMainTrace ? 1 : 0,
+    residual_ledger: invalidMainTrace ? {
+      coordinates: {
+        "trc:trace-normal-form": {
+          name: "trc:trace-normal-form",
+          value: 1,
+          unit: "dimensionless",
+          kind: "residual",
+          description: "main-frontier records require executable trace normal forms"
+        }
+      }
+    } : { coordinates: {} },
+    reasons
+  };
+}
+
+// src/io/portability.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname2, isAbsolute, normalize as normalize2, resolve as resolve2, sep as sep2 } from "path";
+function normalizedSha256(text) {
+  return createHash("sha256").update(lfNormalize(text), "utf8").digest("hex");
+}
+function stableCompactJson(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableCompactJson(item)).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    const input = value;
+    return `{${Object.keys(input).sort().map((key) => `${JSON.stringify(key)}:${stableCompactJson(input[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function safeManifestTarget(base, file) {
+  if (!file || isAbsolute(file)) {
+    return null;
+  }
+  const normalized = normalize2(file);
+  if (normalized.split(/[\\/]+/).includes("..")) {
+    return null;
+  }
+  const baseResolved = resolve2(base);
+  const target = resolve2(baseResolved, normalized);
+  if (target !== baseResolved && !target.startsWith(`${baseResolved}${sep2}`)) {
+    return null;
+  }
+  return target;
+}
+function verifyPortabilityManifest(manifestPath) {
+  const manifest = parseJsonObject(
+    readFileSync6(manifestPath, "utf8"),
+    "portability manifest"
+  );
+  const base = dirname2(manifestPath);
+  const knownSchemas = new Set(schemaNames());
+  const checkedExamples = {};
+  const checkedNegativeExamples = {};
+  const checkedSchemas = {};
+  const sha = {};
+  const reasons = [];
+  let unexpectedFailureCount = 0;
+  let expectedFailureCount = 0;
+  if (!Array.isArray(manifest.examples)) {
+    reasons.push("manifest examples must be a list");
+  }
+  if (!Array.isArray(manifest.negative_examples)) {
+    reasons.push("manifest negative_examples must be a list");
+  }
+  for (const entry of Array.isArray(manifest.examples) ? manifest.examples : []) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      reasons.push("manifest example entry must be an object");
+      continue;
+    }
+    const example = entry;
+    const file = String(example.file ?? "");
+    const schema = String(example.schema ?? "");
+    const expectedSha = example.sha256 ? String(example.sha256) : "";
+    if (typeof example.file !== "string" || typeof example.schema !== "string") {
+      reasons.push("manifest example entries require string file and schema");
+      continue;
+    }
+    checkedSchemas[file] = schema;
+    const path = safeManifestTarget(base, file);
+    if (path === null) {
+      checkedExamples[file] = "unsafe-path";
+      reasons.push(`${file}: example path is outside manifest directory`);
+      unexpectedFailureCount += 1;
+      continue;
+    }
+    if (!existsSync4(path)) {
+      checkedExamples[file] = "missing";
+      reasons.push(`${file}: example file is missing`);
+      unexpectedFailureCount += 1;
+      continue;
+    }
+    if (!knownSchemas.has(schema)) {
+      checkedExamples[file] = "unknown-schema";
+      reasons.push(`${schema} is not a known schema`);
+      unexpectedFailureCount += 1;
+      continue;
+    }
+    const text = readFileSync6(path, "utf8");
+    const digest = normalizedSha256(text);
+    sha[file] = digest;
+    if (expectedSha && digest !== expectedSha) {
+      checkedExamples[file] = "sha256-mismatch";
+      reasons.push(`${file}: sha256 does not match manifest`);
+      unexpectedFailureCount += 1;
+      continue;
+    }
+    const data = parseJsonObject(text, file);
+    const validation = validateByType(data, schema);
+    checkedExamples[file] = validation.valid ? "valid" : "schema-invalid";
+    if (!validation.valid) {
+      unexpectedFailureCount += 1;
+      reasons.push(...validation.errors.map((error) => `${file}: ${error}`));
+    }
+  }
+  for (const entry of Array.isArray(manifest.negative_examples) ? manifest.negative_examples : []) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      reasons.push("manifest negative example entry must be an object");
+      unexpectedFailureCount += 1;
+      continue;
+    }
+    const example = entry;
+    const file = String(example.file ?? "");
+    const schema = String(example.schema ?? "");
+    const expectedStatus = String(example.expected_status ?? "schema-invalid");
+    if (typeof example.file !== "string" || typeof example.schema !== "string" || typeof example.expected_status !== "string") {
+      reasons.push(
+        "manifest negative example entries require string file, schema, and expected_status"
+      );
+      unexpectedFailureCount += 1;
+      continue;
+    }
+    checkedSchemas[file] = schema;
+    const path = safeManifestTarget(base, file);
+    let status;
+    if (path === null) {
+      status = "unsafe-path";
+    } else if (!existsSync4(path)) {
+      status = "missing";
+    } else if (!knownSchemas.has(schema)) {
+      status = "unknown-schema";
+    } else {
+      const text = readFileSync6(path, "utf8");
+      if (example.sha256 && normalizedSha256(text) !== String(example.sha256)) {
+        status = "sha256-mismatch";
+      } else {
+        try {
+          const data = parseJsonObject(text, file);
+          status = validateByType(data, schema).valid ? "valid" : "schema-invalid";
+        } catch {
+          status = "schema-invalid";
+        }
+      }
+    }
+    checkedNegativeExamples[file] = status;
+    if (status === expectedStatus && status !== "valid") {
+      expectedFailureCount += 1;
+    } else {
+      unexpectedFailureCount += 1;
+      reasons.push(`${file} expected ${expectedStatus} but got ${status}`);
+    }
+  }
+  const schemaDigestInput = {
+    public_schema_count: schemaNames().length,
+    schema_names: Object.fromEntries(Object.entries(checkedSchemas).sort())
+  };
+  const schemaDigest = createHash("sha256").update(stableCompactJson(schemaDigestInput), "utf8").digest("hex");
+  const uniqueReasons = [...new Set(reasons)].sort();
+  const accepted = Object.keys(checkedExamples).length > 0 && uniqueReasons.length === 0 && Object.values(checkedExamples).every((status) => status === "valid");
+  return {
+    report_id: "pic-portability-conformance",
+    manifest_path: manifestPath,
+    checked_examples: checkedExamples,
+    checked_negative_examples: checkedNegativeExamples,
+    schema_names: checkedSchemas,
+    sha256: sha,
+    schema_digest: schemaDigest,
+    positive_example_count: Object.keys(checkedExamples).length,
+    negative_example_count: Object.keys(checkedNegativeExamples).length,
+    expected_failure_count: expectedFailureCount,
+    unexpected_failure_count: unexpectedFailureCount,
+    semantic_invariants: Array.isArray(manifest.invariants) ? manifest.invariants.map(String) : [],
+    accepted,
+    operationally_usable: accepted,
+    settled: false,
+    reasons: uniqueReasons
+  };
+}
+
+// src/core/status.ts
+var statusRank = {
+  rejected: 0,
+  expired: 1,
+  diagnostic: 2,
+  relaxed: 3,
+  "risk-provisional": 4,
+  speculative: 5,
+  provisional: 6,
+  partial: 6,
+  settled: 7
+};
+function rankStatus(status) {
+  return statusRank[status];
+}
+function noWorseStatus(left, right) {
+  return rankStatus(left) >= rankStatus(right);
+}
+function decideStatus(rule, presentInput, expiredInput = []) {
+  const present = new Set(presentInput);
+  const expired = new Set(expiredInput);
+  const missing = (values) => [
+    ...new Set(
+      [...values].filter((item) => !present.has(item) || expired.has(item))
+    )
+  ].sort();
+  const hardMissing = missing(rule.hard_domain_obligations ?? []);
+  if (hardMissing.length > 0) {
+    return {
+      status: "rejected",
+      accepted: false,
+      reasons: ["hard-domain obligation absent or expired"],
+      missing_obligations: hardMissing
+    };
+  }
+  let settledMissing = missing(rule.required_for_settled ?? []);
+  if ((rule.required_for_settled ?? []).length === 0 && !rule.allow_empty_settled_rule) {
+    settledMissing = ["settled-rule:nonempty-obligations"];
+  }
+  if (settledMissing.length === 0) {
+    return {
+      status: "settled",
+      accepted: true,
+      reasons: [],
+      missing_obligations: []
+    };
+  }
+  const provisionalMissing = missing(rule.required_for_provisional ?? []);
+  if (provisionalMissing.length === 0) {
+    return {
+      status: "provisional",
+      accepted: true,
+      reasons: ["settled obligations missing; no status promotion"],
+      missing_obligations: settledMissing
+    };
+  }
+  const speculativeMissing = missing(rule.required_for_speculative ?? []);
+  if (speculativeMissing.length === 0) {
+    return {
+      status: "speculative",
+      accepted: true,
+      reasons: ["only speculative transition ledgers are complete"],
+      missing_obligations: [
+        .../* @__PURE__ */ new Set([...settledMissing, ...provisionalMissing])
+      ].sort()
+    };
+  }
+  return {
+    status: "diagnostic",
+    accepted: false,
+    reasons: [
+      "insufficient obligations for settled, provisional, or speculative claim"
+    ],
+    missing_obligations: [
+      .../* @__PURE__ */ new Set([
+        ...settledMissing,
+        ...provisionalMissing,
+        ...speculativeMissing
+      ])
+    ].sort()
+  };
+}
+export {
+  accelerateAgentPhase,
+  buildPhaseAccelerationBenchmark,
+  buildPhaseAccelerationPlan,
+  buildRuntimeStep,
+  compileTrc,
+  decideStatus,
+  minimalRuntimeState,
+  minimalRuntimeStepInput,
+  noWorseStatus,
+  phaseAccelerationCompactPayload,
+  phaseAccelerationRunbook,
+  rankStatus,
+  runAgentCheck,
+  runAgentIntake,
+  runtimeHealth,
+  schemaBundle,
+  schemaByType,
+  schemaNames,
+  sortJson,
+  stableStringify,
+  validateByType,
+  validateData,
+  verifyPortabilityManifest,
+  writeAllSchemas
+};