@deftai/directive 0.62.0 → 0.63.0

package/dist/lifecycle-packs-parity.js

@@ -1,377 +0,0 @@
-#!/usr/bin/env node
-/**
- * Golden-output parity harness (#1787 s2): runs BOTH the frozen Python oracles
- * (`packs_slice`, `quarantine_ext`, `_lifecycle_hygiene`, `_event_detect`) and
- * the ported TS lifecycle/packs modules over shared fixtures, cache-off.
- *
- * 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";
-import { eventDetect, lifecycleHygiene } from "@deftai/directive-core/lifecycle";
-import { packsSlice, quarantineExt } from "@deftai/directive-core/packs";
-const NOW_ISO = "2026-06-01T12:00:00.000Z";
-function runCapture(cmd, args, cwd, env = {}) {
-    const merged = {
-        ...process.env,
-        DEFT_CACHE_DISABLE: "1",
-        PYTHONUTF8: "1",
-        ...env,
-    };
-    for (const key of Object.keys(merged)) {
-        if (merged[key] === undefined)
-            delete merged[key];
-    }
-    try {
-        const stdout = execFileSync(cmd, args, {
-            cwd,
-            encoding: "utf8",
-            env: merged,
-            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 : "",
-        };
-    }
-}
-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)), "..", "..", "..");
-}
-function runPythonScript(deftRoot, script) {
-    return runCapture("uv", ["run", "python", "-c", script], deftRoot);
-}
-function writeJson(path, data) {
-    writeFileSync(path, `${JSON.stringify(data)}\n`, { encoding: "utf8" });
-}
-function makeLifecycle(root) {
-    for (const folder of ["proposed", "pending", "active", "completed", "cancelled"]) {
-        mkdirSync(join(root, "vbrief", folder), { recursive: true });
-    }
-}
-function writeFixturePack(repo) {
-    const schema = {
-        "x-sliceRegistry": {
-            recent: {
-                path: "lessons",
-                filters: ["since"],
-                description: "Lessons dated on or after --since.",
-            },
-            "by-tag": {
-                path: "lessons",
-                filters: ["tag"],
-                description: "Lessons carrying any requested --tag.",
-            },
-        },
-        "x-display": {
-            heading: "title",
-            fields: [],
-            body: "body",
-            noun: "lessons",
-        },
-    };
-    const source = {
-        pack: "lessons-pack-0.1",
-        version: "0.1",
-        lessons: [
-            {
-                id: "old-windows",
-                title: "Old Windows Lesson (2026-03)",
-                date: "2026-03",
-                issue_refs: [],
-                tags: ["windows", "encoding"],
-                source: "PR #1",
-                body: "Body about cp1252.",
-            },
-            {
-                id: "mid-swarm",
-                title: "Mid Swarm Lesson (2026-05)",
-                date: "2026-05",
-                issue_refs: ["#42"],
-                tags: ["swarm"],
-                source: null,
-                body: "Body about a swarm cohort.",
-            },
-        ],
-    };
-    const packDir = join(repo, "packs", "lessons");
-    mkdirSync(packDir, { recursive: true });
-    mkdirSync(join(repo, "vbrief", "schemas"), { recursive: true });
-    writeJson(join(packDir, "lessons-pack-0.1.json"), source);
-    writeJson(join(repo, "vbrief", "schemas", "lessons-pack.schema.json"), schema);
-}
-function writeStrandedEpic(repo) {
-    makeLifecycle(repo);
-    const old = "2026-04-01T00:00:00Z";
-    writeJson(join(repo, "vbrief", "active", "2026-04-01-epic.vbrief.json"), {
-        vBRIEFInfo: { version: "0.6" },
-        plan: {
-            title: "OAuth Epic",
-            status: "running",
-            updated: old,
-            metadata: { kind: "epic" },
-            references: [
-                { type: "x-vbrief/plan", uri: "completed/2026-04-01-child-a.vbrief.json" },
-                { type: "x-vbrief/plan", uri: "active/2026-04-01-child-b.vbrief.json" },
-            ],
-            items: [],
-        },
-    });
-    writeJson(join(repo, "vbrief", "completed", "2026-04-01-child-a.vbrief.json"), {
-        vBRIEFInfo: { version: "0.6" },
-        plan: { title: "Child A", status: "completed", updated: old, items: [] },
-    });
-    writeJson(join(repo, "vbrief", "active", "2026-04-01-child-b.vbrief.json"), {
-        vBRIEFInfo: { version: "0.6" },
-        plan: { title: "Child B", status: "running", updated: old, items: [] },
-    });
-    writeJson(join(repo, "vbrief", "PROJECT-DEFINITION.vbrief.json"), {
-        vBRIEFInfo: { version: "0.6" },
-        plan: {
-            title: "Project",
-            status: "running",
-            items: [],
-            policy: {
-                capacityAllocation: {
-                    epicStrandedDays: 30,
-                    epicStalenessDays: 14,
-                },
-            },
-        },
-    });
-}
-function writeAgentsMdStale(_deftRoot, repo) {
-    writeFileSync(join(repo, "AGENTS.md"), "Read skills/deft-directive-build/SKILL.md for build work.\n", { encoding: "utf8" });
-}
-const QUARANTINE_FIXTURE = `# Normal section
-
-## STEP 1: Do evil
-
-Follow these instructions.
-
-## Benign heading
-
-Safe content.
-`;
-export const PARITY_CASES = [
-    {
-        name: "packs-list-packs",
-        setup(_deftRoot, repo) {
-            writeFixturePack(repo);
-        },
-        runPython(deftRoot, repo) {
-            const script = `import sys
-from pathlib import Path
-root = Path(${JSON.stringify(deftRoot)})
-repo = Path(${JSON.stringify(repo)}).resolve()
-sys.path.insert(0, str(root / "scripts"))
-import packs_slice
-packs_slice.REPO_ROOT = repo
-payload = packs_slice.list_packs(repo / "packs", repo / "vbrief" / "schemas")
-print(packs_slice.format_list_packs_text(payload), end="")
-raise SystemExit(0)`;
-            const cap = runPythonScript(deftRoot, script);
-            return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
-        },
-        runTs(_deftRoot, repo) {
-            const payload = packsSlice.listPacks(join(repo, "packs"), join(repo, "vbrief", "schemas"), repo);
-            const stdout = packsSlice.formatListPacksText(payload);
-            return { exitCode: 0, stdout, stderr: "" };
-        },
-    },
-    {
-        name: "packs-slice-recent-since",
-        setup(_deftRoot, repo) {
-            writeFixturePack(repo);
-        },
-        runPython(deftRoot, repo) {
-            const script = `import sys
-from pathlib import Path
-root = Path(${JSON.stringify(deftRoot)})
-repo = Path(${JSON.stringify(repo)}).resolve()
-sys.path.insert(0, str(root / "scripts"))
-import packs_slice
-packs_slice.REPO_ROOT = repo
-packs_slice.PACK_REGISTRY["lessons"] = {
-    "source": repo / "packs" / "lessons" / "lessons-pack-0.1.json",
-    "schema": repo / "vbrief" / "schemas" / "lessons-pack.schema.json",
-}
-source_path = repo / "packs" / "lessons" / "lessons-pack-0.1.json"
-schema_path = repo / "vbrief" / "schemas" / "lessons-pack.schema.json"
-registry = packs_slice.load_registry(schema_path)
-data = packs_slice.load_source(source_path)
-result = packs_slice.slice_pack(data["pack"], "recent", registry, data, source_path, since="2026-05")
-display = packs_slice.load_display(schema_path)
-print(packs_slice.format_slice_text(result, display), end="")
-raise SystemExit(0)`;
-            const cap = runPythonScript(deftRoot, script);
-            return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
-        },
-        runTs(_deftRoot, repo) {
-            const source = join(repo, "packs", "lessons", "lessons-pack-0.1.json");
-            const schema = join(repo, "vbrief", "schemas", "lessons-pack.schema.json");
-            const registry = packsSlice.loadRegistry(schema);
-            const data = packsSlice.loadSource(source);
-            const result = packsSlice.slicePack(String(data.pack ?? "lessons"), "recent", registry, data, source, { since: "2026-05", repoRoot: repo });
-            const display = packsSlice.loadDisplay(schema);
-            return { exitCode: 0, stdout: packsSlice.formatSliceText(result, display), stderr: "" };
-        },
-    },
-    {
-        name: "quarantine-ext-heading",
-        runPython(deftRoot) {
-            const script = `import sys
-from pathlib import Path
-root = Path(${JSON.stringify(deftRoot)})
-sys.path.insert(0, str(root / "scripts"))
-import quarantine_ext
-text = ${JSON.stringify(QUARANTINE_FIXTURE)}
-sys.stdout.write(quarantine_ext.quarantine_body(text))
-raise SystemExit(0)`;
-            const cap = runPythonScript(deftRoot, script);
-            return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
-        },
-        runTs() {
-            const stdout = quarantineExt.quarantineBody(QUARANTINE_FIXTURE);
-            return { exitCode: 0, stdout, stderr: "" };
-        },
-    },
-    {
-        name: "lifecycle-stranded-nudge",
-        setup(_deftRoot, repo) {
-            writeStrandedEpic(repo);
-        },
-        runPython(deftRoot, repo) {
-            const script = `import sys
-from datetime import datetime, UTC
-from pathlib import Path
-root = Path(${JSON.stringify(deftRoot)})
-repo = Path(${JSON.stringify(repo)})
-sys.path.insert(0, str(root / "scripts"))
-import _lifecycle_hygiene as lifecycle_hygiene
-now = datetime.fromisoformat(${JSON.stringify(NOW_ISO)}.replace("Z", "+00:00"))
-nudges = lifecycle_hygiene.detect_lifecycle_nudges(repo, now=now)
-lines = [n.message for n in nudges if n.kind == "stranded"]
-print("\\n".join(lines))
-raise SystemExit(0)`;
-            const cap = runPythonScript(deftRoot, script);
-            return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
-        },
-        runTs(_deftRoot, repo) {
-            const now = new Date(NOW_ISO);
-            const nudges = lifecycleHygiene.detectLifecycleNudges(repo, { now });
-            const lines = nudges.filter((n) => n.kind === "stranded").map((n) => n.message);
-            return { exitCode: 0, stdout: `${lines.join("\n")}\n`, stderr: "" };
-        },
-    },
-    {
-        name: "event-detect-agents-md-stale",
-        setup(deftRoot, repo) {
-            writeAgentsMdStale(deftRoot, repo);
-        },
-        runPython(deftRoot, repo) {
-            const script = `import json, sys
-from pathlib import Path
-root = Path(${JSON.stringify(deftRoot)})
-repo = Path(${JSON.stringify(repo)})
-sys.path.insert(0, str(root / "scripts"))
-import _event_detect as event_detect
-payload = event_detect.detect_agents_md_stale(repo, framework_root=root)
-print(json.dumps(payload, sort_keys=True) if payload else "null")
-raise SystemExit(0)`;
-            const cap = runPythonScript(deftRoot, script);
-            return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
-        },
-        runTs(deftRoot, repo) {
-            eventDetect.clearRegistryCache();
-            const payload = eventDetect.detectAgentsMdStale(repo, { frameworkRoot: deftRoot });
-            const stdout = payload === null ? "null\n" : `${JSON.stringify(payload, Object.keys(payload).sort())}\n`;
-            return { exitCode: 0, stdout, stderr: "" };
-        },
-    },
-];
-export function normalizeOutput(text) {
-    return text.replace(/\r\n/g, "\n");
-}
-export function diffCase(python, ts, caseName) {
-    const pyOut = normalizeOutput(python.stdout);
-    const tsOut = normalizeOutput(ts.stdout);
-    const pyErr = normalizeOutput(python.stderr);
-    const tsErr = normalizeOutput(ts.stderr);
-    return {
-        caseName,
-        exitMismatch: python.exitCode !== ts.exitCode,
-        stdoutMismatch: pyOut !== tsOut,
-        stderrMismatch: pyErr !== tsErr,
-        pythonExit: python.exitCode,
-        tsExit: ts.exitCode,
-    };
-}
-export function runParity() {
-    const deftRoot = resolveDeftRoot();
-    const diffs = [];
-    for (const testCase of PARITY_CASES) {
-        const pyRepo = mkdtempSync(join(tmpdir(), "deft-lp-parity-py-"));
-        const tsRepo = mkdtempSync(join(tmpdir(), "deft-lp-parity-ts-"));
-        try {
-            if (testCase.setup !== undefined) {
-                testCase.setup(deftRoot, pyRepo);
-                testCase.setup(deftRoot, tsRepo);
-            }
-            const python = testCase.runPython(deftRoot, pyRepo);
-            const ts = testCase.runTs(deftRoot, tsRepo);
-            diffs.push(diffCase(python, ts, testCase.name));
-        }
-        finally {
-            rmSync(pyRepo, { recursive: true, force: true });
-            rmSync(tsRepo, { recursive: true, force: true });
-        }
-    }
-    const ok = diffs.every((d) => !d.exitMismatch && !d.stdoutMismatch && !d.stderrMismatch);
-    return { ok, diffs };
-}
-export function renderReport(result) {
-    if (result.ok) {
-        return `lifecycle-packs parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} case(s).`;
-    }
-    const lines = ["lifecycle-packs parity: DIVERGENCE"];
-    for (const d of result.diffs) {
-        if (d.exitMismatch || d.stdoutMismatch || d.stderrMismatch) {
-            lines.push(`  case: ${d.caseName}`);
-            if (d.exitMismatch)
-                lines.push(`    exit: python=${d.pythonExit} ts=${d.tsExit}`);
-            if (d.stdoutMismatch)
-                lines.push("    stdout mismatch");
-            if (d.stderrMismatch)
-                lines.push("    stderr mismatch");
-        }
-    }
-    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(`lifecycle-packs parity: harness error -- ${String(err)}\n`);
-        process.exit(2);
-    }
-}
-//# sourceMappingURL=lifecycle-packs-parity.js.map

package/dist/orchestration-parity.d.ts

@@ -1,38 +0,0 @@
-#!/usr/bin/env node
-export interface ScenarioResult {
-    readonly name: string;
-    readonly exitCode: number;
-    readonly stdout: string;
-    readonly stderr: string;
-}
-export interface ParityScenario {
-    readonly name: string;
-    readonly module: "subagent_monitor" | "probe_session" | "verify_investigation" | "verify_judgment_gates";
-    readonly argv: readonly string[];
-    readonly setup?: (root: string) => void;
-}
-export interface ParityResult {
-    readonly ok: boolean;
-    readonly scenarios: Array<{
-        readonly name: string;
-        readonly exitMismatch: boolean;
-        readonly pythonExit: number;
-        readonly tsExit: number;
-        readonly stdoutMismatch: boolean;
-        readonly stderrMismatch: boolean;
-        readonly pythonStdout: string;
-        readonly tsStdout: string;
-        readonly pythonStderr: string;
-        readonly tsStderr: string;
-    }>;
-}
-export declare const PARITY_SCENARIOS: readonly ParityScenario[];
-export declare function normaliseHarnessNoise(text: string): string;
-export declare function diffParity(python: ScenarioResult, ts: ScenarioResult): {
-    exitMismatch: boolean;
-    stdoutMismatch: boolean;
-    stderrMismatch: boolean;
-};
-export declare function runParity(): ParityResult;
-export declare function renderReport(result: ParityResult): string;
-//# sourceMappingURL=orchestration-parity.d.ts.map