@deftai/directive 0.62.0 → 0.64.0

package/dist/orchestration-parity.js

@@ -1,364 +0,0 @@
-#!/usr/bin/env node
-/**
- * Golden-output parity harness (#1788 s2): runs BOTH the Python oracles
- * (subagent_monitor, probe_session, verify_investigation, verify_judgment_gates)
- * and the ported TS CLI modules with cache-off, then diffs exit codes and output.
- *
- * Exit codes: 0 parity / 1 divergence / 2 harness setup error.
- */
-import { spawnSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-function closeReadyLedger() {
-    return {
-        vBRIEFInfo: { version: "0.6" },
-        plan: {
-            id: "2026-06-14-example",
-            title: "Why did X happen?",
-            status: "completed",
-            items: [
-                {
-                    id: "branch.slowness",
-                    title: "Why slow",
-                    status: "completed",
-                    items: [
-                        {
-                            id: "claim.slowness.M1",
-                            title: "embed contention",
-                            status: "completed",
-                            metadata: { "x-claim": { evidenceRefs: ["EV-001"] } },
-                        },
-                    ],
-                },
-                {
-                    id: "branch.queue",
-                    title: "Queue wait",
-                    status: "failed",
-                    items: [
-                        {
-                            id: "claim.queue.B1",
-                            title: "saturation",
-                            status: "failed",
-                            metadata: {
-                                "x-claim": {
-                                    ruledOutReason: "active=2, cap=8",
-                                    evidenceRefs: ["EV-002"],
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-            edges: [{ from: "claim.queue.B1", to: "branch.queue", type: "invalidates" }],
-            references: [
-                { id: "EV-001", type: "log-excerpt" },
-                { id: "EV-002", type: "metric-snapshot" },
-            ],
-            metadata: {
-                "x-investigation": {
-                    profile: "forensic-research-v1",
-                    wavesCompleted: { "1": true, "2": true, "3": true, "4": true },
-                },
-            },
-        },
-    };
-}
-function blockedLedger() {
-    const data = closeReadyLedger();
-    data.plan.status = "running";
-    return data;
-}
-function isoMinutesAgo(minutes) {
-    const d = new Date(Date.now() - minutes * 60 * 1000);
-    return d.toISOString().replace(/\.\d{3}Z$/, "Z");
-}
-function writeHeartbeat(scratch, agentId, minutesAgo, phase = "polling") {
-    mkdirSync(scratch, { recursive: true });
-    writeFileSync(join(scratch, `${agentId}.json`), JSON.stringify({
-        agent_id: agentId,
-        parent_id: "parent-test",
-        last_heartbeat_at: isoMinutesAgo(minutesAgo),
-        last_message: "polling Greptile",
-        phase,
-        terminal_state: null,
-    }), "utf8");
-}
-function setupProjectDefinition(root, policy = {}) {
-    mkdirSync(join(root, "vbrief", "proposed"), { recursive: true });
-    mkdirSync(join(root, "vbrief", "pending"), { recursive: true });
-    mkdirSync(join(root, "vbrief", "active"), { recursive: true });
-    mkdirSync(join(root, "vbrief", "completed"), { recursive: true });
-    mkdirSync(join(root, "vbrief", "cancelled"), { recursive: true });
-    writeFileSync(join(root, "vbrief", "PROJECT-DEFINITION.vbrief.json"), JSON.stringify({
-        vBRIEFInfo: { version: "0.6" },
-        plan: { title: "parity", status: "running", items: [], policy },
-    }), "utf8");
-}
-export const PARITY_SCENARIOS = [
-    {
-        name: "monitor-empty-scratch",
-        module: "subagent_monitor",
-        argv: ["--json"],
-        setup: (root) => {
-            mkdirSync(join(root, ".deft-scratch", "subagent-status"), { recursive: true });
-        },
-    },
-    {
-        name: "monitor-fresh-heartbeat",
-        module: "subagent_monitor",
-        argv: ["--json", "--threshold-minutes", "30"],
-        setup: (root) => {
-            writeHeartbeat(join(root, ".deft-scratch", "subagent-status"), "agent-fresh", 1);
-        },
-    },
-    {
-        name: "monitor-stale-heartbeat",
-        module: "subagent_monitor",
-        argv: ["--json", "--threshold-minutes", "30"],
-        setup: (root) => {
-            writeHeartbeat(join(root, ".deft-scratch", "subagent-status"), "agent-stale", 45);
-        },
-    },
-    {
-        name: "monitor-missing-scratch-dir",
-        module: "subagent_monitor",
-        argv: ["--scratch-dir", ".deft-scratch/missing-status", "--json"],
-    },
-    {
-        name: "probe-session-guard-artifact-blocked",
-        module: "probe_session",
-        argv: ["guard-artifact", "--path", "vbrief/proposed/auth-probe.vbrief.json"],
-        setup: (root) => {
-            mkdirSync(join(root, ".deft"), { recursive: true });
-            writeFileSync(join(root, ".deft", "probe-session.json"), `${JSON.stringify({
-                schemaVersion: 1,
-                state: "interrogate",
-                target: "auth-probe",
-                currentBranch: "tokens",
-                resolvedDecisions: [],
-                startedAt: "2026-06-19T12:00:00Z",
-            })}\n`, "utf8");
-        },
-    },
-    {
-        name: "probe-session-complete-then-guard",
-        module: "probe_session",
-        argv: ["guard-artifact", "--path", "vbrief/proposed/auth-probe.vbrief.json"],
-        setup: (root) => {
-            mkdirSync(join(root, ".deft"), { recursive: true });
-            writeFileSync(join(root, ".deft", "probe-session.json"), `${JSON.stringify({
-                schemaVersion: 1,
-                state: "complete",
-                target: "auth-probe",
-                currentBranch: "tokens",
-                resolvedDecisions: [{ question: "Q?", answer: "A.", status: "locked" }],
-                startedAt: "2026-06-19T12:00:00Z",
-                completedAt: "2026-06-19T13:00:00Z",
-            })}\n`, "utf8");
-        },
-    },
-    {
-        name: "investigation-close-clean",
-        module: "verify_investigation",
-        argv: ["--ledger", "ledger.json"],
-        setup: (root) => {
-            writeFileSync(join(root, "ledger.json"), `${JSON.stringify(closeReadyLedger())}\n`, "utf8");
-        },
-    },
-    {
-        name: "investigation-close-blocked",
-        module: "verify_investigation",
-        argv: ["--ledger", "ledger.json"],
-        setup: (root) => {
-            writeFileSync(join(root, "ledger.json"), `${JSON.stringify(blockedLedger())}\n`, "utf8");
-        },
-    },
-    {
-        name: "judgment-gate-advise-secrets",
-        module: "verify_judgment_gates",
-        argv: ["--path", "secrets/prod.env"],
-        setup: (root) => setupProjectDefinition(root),
-    },
-    {
-        name: "judgment-gate-enforce-secrets-blocked",
-        module: "verify_judgment_gates",
-        argv: ["--enforce", "--path", "secrets/prod.env", "--quiet"],
-        setup: (root) => setupProjectDefinition(root),
-    },
-];
-const TS_SCRIPT = {
-    subagent_monitor: "subagent-monitor.js",
-    probe_session: "probe-session.js",
-    verify_investigation: "verify-investigation.js",
-    verify_judgment_gates: "verify-judgment-gates.js",
-};
-const PY_SCRIPT = {
-    subagent_monitor: "subagent_monitor.py",
-    probe_session: "probe_session.py",
-    verify_investigation: "verify_investigation.py",
-    verify_judgment_gates: "verify_judgment_gates.py",
-};
-function runCapture(cmd, args, cwd, env) {
-    const result = spawnSync(cmd, args, {
-        cwd,
-        encoding: "utf8",
-        env: { ...process.env, ...env },
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    return {
-        status: result.status ?? 2,
-        stdout: typeof result.stdout === "string" ? result.stdout : "",
-        stderr: typeof result.stderr === "string" ? result.stderr : "",
-    };
-}
-function resolveDeftRoot() {
-    if (process.env.DEFT_ROOT !== undefined && process.env.DEFT_ROOT.length > 0) {
-        return resolve(process.env.DEFT_ROOT);
-    }
-    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
-}
-export function normaliseHarnessNoise(text) {
-    let out = text
-        .split("\n")
-        .filter((line) => !line.startsWith("Using CPython") &&
-        !line.startsWith("Creating virtual environment") &&
-        !line.startsWith("Installed "))
-        .join("\n");
-    // Monitor JSON emits wall-clock `now` / age_seconds — normalise volatile fields.
-    if (out.trimStart().startsWith("{")) {
-        try {
-            const obj = JSON.parse(out);
-            if (typeof obj.now === "string") {
-                delete obj.now;
-                if (Array.isArray(obj.records)) {
-                    for (const rec of obj.records) {
-                        if (typeof rec === "object" && rec !== null && !Array.isArray(rec)) {
-                            delete rec.age_seconds;
-                        }
-                    }
-                }
-                out = JSON.stringify(obj, null, 2);
-            }
-        }
-        catch {
-            // not JSON — leave as-is
-        }
-    }
-    return out;
-}
-export function diffParity(python, ts) {
-    const pythonStdout = normaliseHarnessNoise(python.stdout);
-    const tsStdout = normaliseHarnessNoise(ts.stdout);
-    const pythonStderr = normaliseHarnessNoise(python.stderr);
-    const tsStderr = normaliseHarnessNoise(ts.stderr);
-    return {
-        exitMismatch: python.exitCode !== ts.exitCode,
-        stdoutMismatch: pythonStdout !== tsStdout,
-        stderrMismatch: pythonStderr !== tsStderr,
-    };
-}
-function runScenario(deftRoot, scenario) {
-    const root = mkdtempSync(join(tmpdir(), "deft-orchestration-parity-"));
-    try {
-        if (scenario.setup) {
-            scenario.setup(root);
-        }
-        const env = {
-            DEFT_CACHE_DISABLE: "1",
-            PYTHONUTF8: "1",
-        };
-        const pyScript = join(deftRoot, "scripts", PY_SCRIPT[scenario.module]);
-        const pyArgs = ["run", "python", pyScript];
-        if (scenario.module === "probe_session" || scenario.module === "verify_judgment_gates") {
-            pyArgs.push("--project-root", root, ...scenario.argv);
-        }
-        else if (scenario.module === "verify_investigation") {
-            pyArgs.push(...scenario.argv.map((a) => (a === "ledger.json" ? join(root, "ledger.json") : a)));
-            pyArgs.push("--project-root", root);
-        }
-        else {
-            pyArgs.push(...scenario.argv);
-        }
-        const tsScript = join(deftRoot, "packages", "cli", "dist", TS_SCRIPT[scenario.module]);
-        const tsArgs = [tsScript];
-        if (scenario.module === "probe_session" || scenario.module === "verify_judgment_gates") {
-            tsArgs.push("--project-root", root, ...scenario.argv);
-        }
-        else if (scenario.module === "verify_investigation") {
-            tsArgs.push(...scenario.argv.map((a) => (a === "ledger.json" ? join(root, "ledger.json") : a)));
-            tsArgs.push("--project-root", root);
-        }
-        else {
-            tsArgs.push(...scenario.argv);
-        }
-        const py = runCapture("uv", pyArgs, scenario.module === "subagent_monitor" ? root : deftRoot, env);
-        const ts = runCapture("node", tsArgs, scenario.module === "subagent_monitor" ? root : deftRoot, env);
-        return {
-            python: { name: scenario.name, exitCode: py.status, stdout: py.stdout, stderr: py.stderr },
-            ts: { name: scenario.name, exitCode: ts.status, stdout: ts.stdout, stderr: ts.stderr },
-        };
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-}
-export function runParity() {
-    const deftRoot = resolveDeftRoot();
-    process.env.DEFT_ROOT = deftRoot;
-    const scenarios = [];
-    for (const scenario of PARITY_SCENARIOS) {
-        const ran = runScenario(deftRoot, scenario);
-        const diff = diffParity(ran.python, ran.ts);
-        scenarios.push({
-            name: scenario.name,
-            pythonExit: ran.python.exitCode,
-            tsExit: ran.ts.exitCode,
-            pythonStdout: normaliseHarnessNoise(ran.python.stdout),
-            tsStdout: normaliseHarnessNoise(ran.ts.stdout),
-            pythonStderr: normaliseHarnessNoise(ran.python.stderr),
-            tsStderr: normaliseHarnessNoise(ran.ts.stderr),
-            ...diff,
-        });
-    }
-    const ok = scenarios.every((s) => !s.exitMismatch && !s.stdoutMismatch && !s.stderrMismatch);
-    return { ok, scenarios };
-}
-export function renderReport(result) {
-    if (result.ok) {
-        return `orchestration parity: CLEAN -- Python and TS agree on ${result.scenarios.length} case(s).`;
-    }
-    const lines = ["orchestration parity: DIVERGENCE"];
-    for (const s of result.scenarios) {
-        if (s.exitMismatch || s.stdoutMismatch || s.stderrMismatch) {
-            lines.push(`  scenario: ${s.name}`);
-            if (s.exitMismatch) {
-                lines.push(`    exit mismatch: python=${s.pythonExit} ts=${s.tsExit}`);
-            }
-            if (s.stdoutMismatch) {
-                lines.push(`    stdout mismatch (python ${s.pythonStdout.length} / ts ${s.tsStdout.length} bytes)`);
-            }
-            if (s.stderrMismatch) {
-                lines.push(`    stderr mismatch (python ${s.pythonStderr.length} / ts ${s.tsStderr.length} bytes)`);
-            }
-        }
-    }
-    return lines.join("\n");
-}
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
-    try {
-        const result = runParity();
-        if (result.ok) {
-            process.stdout.write(`${renderReport(result)}\n`);
-            process.exit(0);
-        }
-        process.stderr.write(`${renderReport(result)}\n`);
-        process.exit(1);
-    }
-    catch (err) {
-        process.stderr.write(`orchestration parity: harness error -- ${String(err)}\n`);
-        process.exit(2);
-    }
-}
-//# sourceMappingURL=orchestration-parity.js.map

package/dist/parity.d.ts

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-export interface ParityFinding {
-    readonly path: string;
-    readonly line: number;
-    readonly label: string;
-}
-export interface GateOutput {
-    readonly exitCode: number;
-    readonly findings: ParityFinding[];
-}
-export interface ParityResult {
-    readonly ok: boolean;
-    readonly pythonExit: number;
-    readonly tsExit: number;
-    readonly exitMismatch: boolean;
-    readonly onlyPython: string[];
-    readonly onlyTs: string[];
-}
-/** Parse the rendered finding lines out of a gate's stderr. */
-export declare function parseFindings(stderr: string): ParityFinding[];
-/** Stable key for a finding (path:line:label). */
-export declare function findingKey(f: ParityFinding): string;
-/** Diff two gate outputs into a structured parity result. */
-export declare function diffGates(python: GateOutput, ts: GateOutput): ParityResult;
-/**
- * Fixture corpus exercised by the parity harness. Each entry maps a repo-rel
- * path to its exact textual content. Covers: clean files, U+FFFD, cp437/cp1252
- * mojibake, unexpected/ tolerated BOM, vBRIEF narrative control chars, markdown
- * code-span false-positive guard, and the `-798-` allow-list carve-out.
- */
-export declare const PARITY_FIXTURES: ReadonlyArray<readonly [string, string]>;
-/** Build the throwaway git repo with all fixtures; return its root path. */
-export declare function buildFixtureRepo(): string;
-/** Run both gates against a fresh fixture repo and diff them. */
-export declare function runParity(): ParityResult;
-//# sourceMappingURL=parity.d.ts.map

package/dist/parity.js

@@ -1,176 +0,0 @@
-#!/usr/bin/env node
-/**
- * Golden-output parity harness (#1718): builds a throwaway git repo of
- * known-corruption fixtures, runs BOTH the Python oracle
- * (`scripts/verify_encoding.py`) and the ported TS gate against it with the
- * cache off, and diffs structured findings + exit codes. A clean run proves
- * the TS port detects identically to the Python implementation it replaces.
- *
- * Exit codes: 0 parity / 1 divergence / 2 harness setup error.
- */
-import { execFileSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-// Finding render is `  path:line [label] context`; capture path / line / label.
-const FINDING_RE = /^ {2}(.+?):(\d+) \[(.+?)\] /;
-/** Parse the rendered finding lines out of a gate's stderr. */
-export function parseFindings(stderr) {
-    const out = [];
-    for (const line of stderr.split(/\r?\n/)) {
-        const m = FINDING_RE.exec(line);
-        if (m !== null) {
-            out.push({ path: m[1], line: Number(m[2]), label: m[3] });
-        }
-    }
-    return out;
-}
-/** Stable key for a finding (path:line:label). */
-export function findingKey(f) {
-    return `${f.path}:${f.line}:${f.label}`;
-}
-/** Diff two gate outputs into a structured parity result. */
-export function diffGates(python, ts) {
-    const pyKeys = new Set(python.findings.map(findingKey));
-    const tsKeys = new Set(ts.findings.map(findingKey));
-    const onlyPython = [...pyKeys].filter((k) => !tsKeys.has(k)).sort();
-    const onlyTs = [...tsKeys].filter((k) => !pyKeys.has(k)).sort();
-    const exitMismatch = python.exitCode !== ts.exitCode;
-    return {
-        ok: !exitMismatch && onlyPython.length === 0 && onlyTs.length === 0,
-        pythonExit: python.exitCode,
-        tsExit: ts.exitCode,
-        exitMismatch,
-        onlyPython,
-        onlyTs,
-    };
-}
-function runCapture(cmd, args, cwd) {
-    try {
-        const stdout = execFileSync(cmd, args, {
-            cwd,
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        return { status: 0, stdout, stderr: "" };
-    }
-    catch (err) {
-        const e = err;
-        return {
-            status: typeof e.status === "number" ? e.status : 2,
-            stdout: typeof e.stdout === "string" ? e.stdout : "",
-            stderr: typeof e.stderr === "string" ? e.stderr : "",
-        };
-    }
-}
-const BOM = "\ufeff";
-/**
- * Fixture corpus exercised by the parity harness. Each entry maps a repo-rel
- * path to its exact textual content. Covers: clean files, U+FFFD, cp437/cp1252
- * mojibake, unexpected/ tolerated BOM, vBRIEF narrative control chars, markdown
- * code-span false-positive guard, and the `-798-` allow-list carve-out.
- */
-export const PARITY_FIXTURES = [
-    ["clean.md", "# Title\n\nplain ascii prose\n"],
-    ["ufffd.txt", "line one\nbroken \ufffd marker\n"],
-    ["cp437.md", "a cp437 glyph \u0393\u00a3\u00f4 in prose\n"],
-    ["cp1252.txt", "a smart \u00e2\u20ac\u2122 quote in prose\n"],
-    ["bom.json", `${BOM}{"a": 1}\n`],
-    ["tolerated-bom.ps1", `${BOM}Write-Host 'ok'\n`],
-    ["md-quoted.md", "see the bigon `\u0393\u00a3\u00f4` inside a code span\n"],
-    [
-        "vbrief/active/2026-01-01-1-x.vbrief.json",
-        `${JSON.stringify({ plan: { narratives: { problem: "has a \u000b vtab" } } }, null, 2)}\n`,
-    ],
-    [
-        "vbrief/active/2026-01-01-798-recurrence.vbrief.json",
-        `${JSON.stringify({ plan: { narratives: { problem: "catalogs \u0393\u00a3\u00f4" } } }, null, 2)}\n`,
-    ],
-];
-/** Build the throwaway git repo with all fixtures; return its root path. */
-export function buildFixtureRepo() {
-    const root = mkdtempSync(join(tmpdir(), "deft-encoding-parity-"));
-    // mkdtempSync already created the dir, so any failure below (a write error or
-    // git not being on PATH) must clean it up here -- the try/finally in
-    // runParity only fires once this function returns the path successfully.
-    try {
-        for (const [rel, content] of PARITY_FIXTURES) {
-            const full = join(root, rel);
-            mkdirSync(dirname(full), { recursive: true });
-            writeFileSync(full, content, { encoding: "utf8" });
-        }
-        execFileSync("git", ["init", "-q"], { cwd: root });
-        execFileSync("git", ["add", "-A"], { cwd: root });
-    }
-    catch (err) {
-        rmSync(root, { recursive: true, force: true });
-        throw err;
-    }
-    return root;
-}
-function resolveDeftRoot() {
-    if (process.env.DEFT_ROOT !== undefined && process.env.DEFT_ROOT.length > 0) {
-        return resolve(process.env.DEFT_ROOT);
-    }
-    // dist layout: packages/cli/dist/parity.js -> repo root is three levels up.
-    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
-}
-/** Run both gates against a fresh fixture repo and diff them. */
-export function runParity() {
-    const deftRoot = resolveDeftRoot();
-    const repo = buildFixtureRepo();
-    try {
-        const py = runCapture("uv", [
-            "run",
-            "python",
-            join(deftRoot, "scripts", "verify_encoding.py"),
-            "--all",
-            "--project-root",
-            repo,
-        ], deftRoot);
-        const ts = runCapture("node", [
-            join(deftRoot, "packages", "cli", "dist", "verify-encoding.js"),
-            "--all",
-            "--project-root",
-            repo,
-        ], deftRoot);
-        return diffGates({ exitCode: py.status, findings: parseFindings(py.stderr) }, { exitCode: ts.status, findings: parseFindings(ts.stderr) });
-    }
-    finally {
-        rmSync(repo, { recursive: true, force: true });
-    }
-}
-function renderReport(result) {
-    if (result.ok) {
-        return `verify_encoding parity: CLEAN -- Python and TS agree (exit ${result.pythonExit}).`;
-    }
-    const lines = ["verify_encoding parity: DIVERGENCE"];
-    if (result.exitMismatch) {
-        lines.push(`  exit mismatch: python=${result.pythonExit} ts=${result.tsExit}`);
-    }
-    for (const k of result.onlyPython) {
-        lines.push(`  only python: ${k}`);
-    }
-    for (const k of result.onlyTs) {
-        lines.push(`  only ts:     ${k}`);
-    }
-    return lines.join("\n");
-}
-// Normalize via fileURLToPath so this fires on Windows too (see verify-encoding.ts).
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
-    try {
-        const result = runParity();
-        if (result.ok) {
-            process.stdout.write(`${renderReport(result)}\n`);
-            process.exit(0);
-        }
-        process.stderr.write(`${renderReport(result)}\n`);
-        process.exit(1);
-    }
-    catch (err) {
-        process.stderr.write(`verify_encoding parity: harness error -- ${String(err)}\n`);
-        process.exit(2);
-    }
-}
-//# sourceMappingURL=parity.js.map

package/dist/platform-parity.d.ts

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-export interface ParityCase {
-    readonly name: string;
-    readonly runPython: (deftRoot: string, repo: string) => unknown;
-    readonly runTs: (deftRoot: string, repo: string) => unknown;
-    readonly setup?: (repo: string) => void;
-}
-export interface ParityDiff {
-    readonly caseName: string;
-    readonly mismatch: boolean;
-    readonly pythonJson: string;
-    readonly tsJson: string;
-}
-export interface ParityResult {
-    readonly ok: boolean;
-    readonly diffs: ParityDiff[];
-}
-/** Strip volatile filesystem paths from capability reports before compare. */
-export declare function normalizeCapabilityReport(value: unknown): unknown;
-/** Normalise volatile agents-refresh plan fields for comparison. */
-export declare function normalizeAgentsPlan(plan: Record<string, unknown>): Record<string, unknown>;
-export declare const PARITY_CASES: readonly ParityCase[];
-export declare function diffCase(name: string, python: unknown, ts: unknown): ParityDiff;
-export declare function runParity(): ParityResult;
-export declare function renderReport(result: ParityResult): string;
-//# sourceMappingURL=platform-parity.d.ts.map