@deftai/directive-core 0.55.0

package/dist/vbrief-reconcile/graph.d.ts

@@ -0,0 +1,11 @@
+import type { ReconcileGraphOutcome } from "./types.js";
+export declare const RESOLVED_FOLDERS: readonly ["completed", "cancelled"];
+export declare function depResolved(dep: string, knownIds: Record<string, [string, string]>): boolean;
+export interface ReconcileGraphOptions {
+    readonly force?: boolean;
+    readonly dryRun?: boolean;
+}
+export declare function reconcileGraph(projectRoot: string, options?: ReconcileGraphOptions): [number, ReconcileGraphOutcome];
+export declare function renderGraphReport(outcome: ReconcileGraphOutcome): string;
+export declare function graphOutcomeToJson(outcome: ReconcileGraphOutcome): Record<string, unknown>;
+//# sourceMappingURL=graph.d.ts.map

package/dist/vbrief-reconcile/graph.js

@@ -0,0 +1,171 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { countVbriefWip, resolveWipCap } from "../policy/wip.js";
+import { runTransition } from "../scope/transition.js";
+import { allScopeIds, asStrList, candidateDepGraph, candidateFromPath, markCycles, } from "./swarm-deps.js";
+export const RESOLVED_FOLDERS = ["completed", "cancelled"];
+const CYCLE_MARKER = "dependency cycle:";
+function resolveWipState(projectRoot) {
+    const capResult = resolveWipCap(projectRoot);
+    const cap = capResult.cap;
+    const count = countVbriefWip(projectRoot);
+    return [cap, count];
+}
+export function depResolved(dep, knownIds) {
+    const known = knownIds[dep];
+    if (!known)
+        return false;
+    const [path] = known;
+    const folder = path.split(/[/\\]/).slice(-2, -1)[0] ?? "";
+    return RESOLVED_FOLDERS.includes(folder);
+}
+function unresolvedDeps(candidate, knownIds) {
+    return asStrList(candidate.swarm.depends_on).filter((dep) => !depResolved(dep, knownIds));
+}
+function candidateInCycle(candidate) {
+    return candidate.blocked.some((r) => r.startsWith(CYCLE_MARKER));
+}
+export function reconcileGraph(projectRoot, options = {}) {
+    const root = resolve(projectRoot);
+    const proposedDir = join(root, "vbrief", "proposed");
+    if (!existsSync(proposedDir)) {
+        return [
+            2,
+            {
+                promoted: [],
+                deferredWip: [],
+                waiting: [],
+                cycles: [],
+                errors: [],
+                cap: 0,
+                count: 0,
+                dryRun: options.dryRun ?? false,
+                forced: options.force ?? false,
+            },
+        ];
+    }
+    const candidatePaths = readdirSync(proposedDir)
+        .filter((f) => f.endsWith(".vbrief.json"))
+        .sort()
+        .map((f) => join(proposedDir, f));
+    const candidates = candidatePaths
+        .map((p) => candidateFromPath(p, root))
+        .filter((c) => c !== null);
+    const knownIds = allScopeIds(root);
+    for (const cand of candidates) {
+        if (!knownIds[cand.storyId])
+            knownIds[cand.storyId] = [cand.path, cand.status];
+    }
+    const graph = candidateDepGraph(candidates, knownIds);
+    markCycles(candidates, graph);
+    const [cap, count] = resolveWipState(root);
+    const outcome = {
+        promoted: [],
+        deferredWip: [],
+        waiting: [],
+        cycles: [],
+        errors: [],
+        cap,
+        count,
+        dryRun: options.dryRun ?? false,
+        forced: options.force ?? false,
+    };
+    const eligible = [];
+    for (const cand of [...candidates].sort((a, b) => a.storyId.localeCompare(b.storyId))) {
+        if (candidateInCycle(cand)) {
+            const cycleReason = cand.blocked.find((r) => r.startsWith(CYCLE_MARKER)) ?? "";
+            outcome.cycles.push(`${cand.storyId}: ${cycleReason}`);
+            continue;
+        }
+        const deps = asStrList(cand.swarm.depends_on);
+        if (deps.length === 0)
+            continue;
+        const unresolved = unresolvedDeps(cand, knownIds);
+        if (unresolved.length > 0) {
+            outcome.waiting.push({ story_id: cand.storyId, unresolved });
+            continue;
+        }
+        eligible.push(cand);
+    }
+    let runningCount = count;
+    for (const cand of eligible) {
+        if (runningCount >= cap && !options.force) {
+            outcome.deferredWip.push(cand.storyId);
+            continue;
+        }
+        if (options.dryRun) {
+            outcome.promoted.push(cand.storyId);
+            runningCount += 1;
+            continue;
+        }
+        const result = runTransition("promote", cand.path);
+        if (!result.ok) {
+            outcome.errors.push({ story_id: cand.storyId, message: result.message });
+            continue;
+        }
+        outcome.promoted.push(cand.storyId);
+        runningCount += 1;
+    }
+    return [outcome.cycles.length > 0 ? 1 : 0, { ...outcome, count: runningCount }];
+}
+export function renderGraphReport(outcome) {
+    const lines = ["vBRIEF reconcile graph", ""];
+    const suffix = outcome.dryRun ? " (dry-run)" : "";
+    lines.push(`Promoted${suffix}:`);
+    if (outcome.promoted.length > 0) {
+        for (const id of outcome.promoted)
+            lines.push(`- ${id}`);
+    }
+    else {
+        lines.push("- none");
+    }
+    lines.push("");
+    lines.push(`Deferred (WIP cap ${outcome.count}/${outcome.cap}):`);
+    if (outcome.deferredWip.length > 0) {
+        for (const id of outcome.deferredWip)
+            lines.push(`- ${id}`);
+    }
+    else {
+        lines.push("- none");
+    }
+    lines.push("");
+    lines.push("Waiting (deps unresolved):");
+    if (outcome.waiting.length > 0) {
+        for (const w of outcome.waiting) {
+            lines.push(`- ${w.story_id}: needs ${w.unresolved.join(", ")}`);
+        }
+    }
+    else {
+        lines.push("- none");
+    }
+    lines.push("");
+    lines.push("Cycles:");
+    if (outcome.cycles.length > 0) {
+        for (const entry of outcome.cycles)
+            lines.push(`- ${entry}`);
+    }
+    else {
+        lines.push("- none");
+    }
+    if (outcome.errors.length > 0) {
+        lines.push("");
+        lines.push("Errors:");
+        for (const err of outcome.errors)
+            lines.push(`- ${err.story_id}: ${err.message}`);
+    }
+    return lines.join("\n");
+}
+export function graphOutcomeToJson(outcome) {
+    return {
+        promoted: [...outcome.promoted],
+        deferred_wip: [...outcome.deferredWip],
+        waiting: outcome.waiting.map((w) => ({ story_id: w.story_id, unresolved: w.unresolved })),
+        cycles: [...outcome.cycles],
+        errors: outcome.errors.map((e) => ({ story_id: e.story_id, message: e.message })),
+        cap: outcome.cap,
+        count: outcome.count,
+        dry_run: outcome.dryRun,
+        forced: outcome.forced,
+    };
+}
+//# sourceMappingURL=graph.js.map

package/dist/vbrief-reconcile/index.d.ts

@@ -0,0 +1,10 @@
+export { depResolved, graphOutcomeToJson, RESOLVED_FOLDERS, reconcileGraph, renderGraphReport, } from "./graph.js";
+export { computeDesiredLabels, labelsOutcomeToJson, MANAGED_LABELS, reconcileLabels, renderLabelsReport, SCAN_FOLDERS, ScmLabelClient, ScmLabelError, } from "./labels.js";
+export { cmdVbriefReconcile, run, usage } from "./main.js";
+export { PARITY_SCENARIO_NAMES, renderScenarioOutput, runParityScenario, } from "./parity-scenarios.js";
+export { pyRepr } from "./py-repr.js";
+export { buildSpecTaskIndex, detectStatusMarker, folderFromStatus, formatReconciliationMarkdown, hasDisagreement, loadOverrides, normalizeTaskId, OVERRIDES_FILENAME, parseOverridesYaml, reconcileScopeItems, writeReconciliationReport, } from "./reconciliation.js";
+export { allScopeIds, asStrList, candidateDepGraph, candidateFromPath, markCycles, } from "./swarm-deps.js";
+export type { Candidate, Child, ConflictEntry, LabelChange, LabelClient, ReconciledItem, ReconcileGraphOutcome, ReconcileLabelsOutcome, ReconcileUmbrellasOutcome, ReconciliationReport, SpecTaskEntry, UmbrellaChange, UmbrellaClient, } from "./types.js";
+export { buildChildIndex, CHILD_REF_TYPE, CLOSED_FOLDERS, childFromData, classifyPassType, computeChildren, computeWaves, LIFECYCLE_FOLDERS, nowIso, OPEN_FOLDERS, parseCurrentShape, reconcileUmbrellas, renderBody, renderUmbrellasReport, ScmUmbrellaClient, UmbrellaScmError, umbrellasOutcomeToJson, } from "./umbrellas.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/vbrief-reconcile/index.js

@@ -0,0 +1,9 @@
+export { depResolved, graphOutcomeToJson, RESOLVED_FOLDERS, reconcileGraph, renderGraphReport, } from "./graph.js";
+export { computeDesiredLabels, labelsOutcomeToJson, MANAGED_LABELS, reconcileLabels, renderLabelsReport, SCAN_FOLDERS, ScmLabelClient, ScmLabelError, } from "./labels.js";
+export { cmdVbriefReconcile, run, usage } from "./main.js";
+export { PARITY_SCENARIO_NAMES, renderScenarioOutput, runParityScenario, } from "./parity-scenarios.js";
+export { pyRepr } from "./py-repr.js";
+export { buildSpecTaskIndex, detectStatusMarker, folderFromStatus, formatReconciliationMarkdown, hasDisagreement, loadOverrides, normalizeTaskId, OVERRIDES_FILENAME, parseOverridesYaml, reconcileScopeItems, writeReconciliationReport, } from "./reconciliation.js";
+export { allScopeIds, asStrList, candidateDepGraph, candidateFromPath, markCycles, } from "./swarm-deps.js";
+export { buildChildIndex, CHILD_REF_TYPE, CLOSED_FOLDERS, childFromData, classifyPassType, computeChildren, computeWaves, LIFECYCLE_FOLDERS, nowIso, OPEN_FOLDERS, parseCurrentShape, reconcileUmbrellas, renderBody, renderUmbrellasReport, ScmUmbrellaClient, UmbrellaScmError, umbrellasOutcomeToJson, } from "./umbrellas.js";
+//# sourceMappingURL=index.js.map

package/dist/vbrief-reconcile/labels.d.ts

@@ -0,0 +1,22 @@
+import { RESOLVED_FOLDERS } from "./graph.js";
+import type { LabelClient, ReconcileLabelsOutcome } from "./types.js";
+export declare const SCAN_FOLDERS: readonly ["proposed", "pending", "active"];
+export declare const MANAGED_LABELS: readonly ["status:blocked", "epic", "status:tracker", "rfc"];
+export declare class ScmLabelError extends Error {
+    name: string;
+}
+export declare function computeDesiredLabels(plan: Record<string, unknown>, unresolvedDeps: boolean): Set<string>;
+export declare class ScmLabelClient implements LabelClient {
+    fetchLabels(repo: string, issueNumber: number): string[];
+    apply(repo: string, issueNumber: number, add: readonly string[], remove: readonly string[]): void;
+}
+export interface ReconcileLabelsOptions {
+    readonly repo?: string | null;
+    readonly dryRun?: boolean;
+    readonly client?: LabelClient;
+}
+export declare function reconcileLabels(projectRoot: string, options?: ReconcileLabelsOptions): [number, ReconcileLabelsOutcome];
+export declare function renderLabelsReport(outcome: ReconcileLabelsOutcome): string;
+export declare function labelsOutcomeToJson(outcome: ReconcileLabelsOutcome): Record<string, unknown>;
+export { RESOLVED_FOLDERS };
+//# sourceMappingURL=labels.d.ts.map

package/dist/vbrief-reconcile/labels.js

@@ -0,0 +1,252 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { call } from "../scm/call.js";
+import { extractIssueRef } from "../triage/reconcile/parse-uri.js";
+import { depResolved, RESOLVED_FOLDERS } from "./graph.js";
+import { allScopeIds, asStrList } from "./swarm-deps.js";
+export const SCAN_FOLDERS = ["proposed", "pending", "active"];
+export const MANAGED_LABELS = ["status:blocked", "epic", "status:tracker", "rfc"];
+const SCM_SOURCE = "github-issue";
+export class ScmLabelError extends Error {
+    name = "ScmLabelError";
+}
+export function computeDesiredLabels(plan, unresolvedDeps) {
+    const desired = new Set();
+    const status = plan.status;
+    const metadata = typeof plan.metadata === "object" && plan.metadata !== null && !Array.isArray(plan.metadata)
+        ? plan.metadata
+        : {};
+    const kind = metadata.kind;
+    if (status === "blocked" || unresolvedDeps)
+        desired.add("status:blocked");
+    if (kind === "epic") {
+        desired.add("epic");
+        desired.add("status:tracker");
+    }
+    else if (kind === "research") {
+        desired.add("rfc");
+    }
+    return desired;
+}
+export class ScmLabelClient {
+    fetchLabels(repo, issueNumber) {
+        const proc = call(SCM_SOURCE, "issue", [
+            "view",
+            String(issueNumber),
+            "--repo",
+            repo,
+            "--json",
+            "labels",
+        ]);
+        if (proc.returncode !== 0) {
+            throw new ScmLabelError(`issue view #${issueNumber} (${repo}) failed: ${(proc.stderr || "").trim()}`);
+        }
+        let data;
+        try {
+            data = JSON.parse(proc.stdout || "{}");
+        }
+        catch (exc) {
+            throw new ScmLabelError(`issue view #${issueNumber} (${repo}) returned non-JSON: ${String(exc)}`);
+        }
+        const labels = typeof data === "object" && data !== null && !Array.isArray(data)
+            ? data.labels
+            : null;
+        if (!Array.isArray(labels))
+            return [];
+        const names = [];
+        for (const entry of labels) {
+            if (typeof entry === "object" && entry !== null && !Array.isArray(entry)) {
+                const name = entry.name;
+                if (typeof name === "string")
+                    names.push(name);
+            }
+            else if (typeof entry === "string") {
+                names.push(entry);
+            }
+        }
+        return names;
+    }
+    apply(repo, issueNumber, add, remove) {
+        const args = ["edit", String(issueNumber), "--repo", repo];
+        for (const name of add)
+            args.push("--add-label", name);
+        for (const name of remove)
+            args.push("--remove-label", name);
+        const proc = call(SCM_SOURCE, "issue", args);
+        if (proc.returncode !== 0) {
+            throw new ScmLabelError(`issue edit #${issueNumber} (${repo}) failed: ${(proc.stderr || "").trim()}`);
+        }
+    }
+}
+function hasUnresolvedDeps(swarm, knownIds) {
+    return asStrList(swarm.depends_on).some((dep) => !depResolved(dep, knownIds));
+}
+export function reconcileLabels(projectRoot, options = {}) {
+    const root = resolve(projectRoot);
+    const vbriefDir = join(root, "vbrief");
+    if (!existsSync(vbriefDir)) {
+        return [
+            2,
+            {
+                changed: [],
+                unchanged: [],
+                skipped_no_ref: [],
+                errors: [],
+                dry_run: options.dryRun ?? false,
+            },
+        ];
+    }
+    const client = options.client ?? new ScmLabelClient();
+    const knownIds = allScopeIds(root);
+    const outcome = {
+        changed: [],
+        unchanged: [],
+        skipped_no_ref: [],
+        errors: [],
+        dry_run: options.dryRun ?? false,
+    };
+    const seenIssues = new Set();
+    for (const folder of SCAN_FOLDERS) {
+        const folderPath = join(vbriefDir, folder);
+        if (!existsSync(folderPath))
+            continue;
+        const files = readdirSync(folderPath)
+            .filter((f) => f.endsWith(".vbrief.json"))
+            .sort();
+        for (const file of files) {
+            const path = join(folderPath, file);
+            let data;
+            try {
+                data = JSON.parse(readFileSync(path, "utf8"));
+            }
+            catch {
+                continue;
+            }
+            if (typeof data !== "object" || data === null)
+                continue;
+            const plan = typeof data.plan === "object" && data.plan !== null && !Array.isArray(data.plan)
+                ? data.plan
+                : {};
+            const storyId = String(plan.id ?? file.slice(0, -".vbrief.json".length));
+            const [refRepo, number] = extractIssueRef(data);
+            const effectiveRepo = refRepo ?? options.repo ?? null;
+            if (number === null || effectiveRepo === null) {
+                outcome.skipped_no_ref.push(storyId);
+                continue;
+            }
+            const key = `${effectiveRepo}:${number}`;
+            if (seenIssues.has(key))
+                continue;
+            seenIssues.add(key);
+            const metadata = typeof plan.metadata === "object" && plan.metadata !== null && !Array.isArray(plan.metadata)
+                ? plan.metadata
+                : {};
+            const swarm = typeof metadata.swarm === "object" &&
+                metadata.swarm !== null &&
+                !Array.isArray(metadata.swarm)
+                ? metadata.swarm
+                : {};
+            const desired = computeDesiredLabels(plan, hasUnresolvedDeps(swarm, knownIds));
+            let current;
+            try {
+                current = client.fetchLabels(effectiveRepo, number);
+            }
+            catch (exc) {
+                outcome.errors.push({ story_id: storyId, message: String(exc) });
+                continue;
+            }
+            const managedSet = new Set(MANAGED_LABELS);
+            const currentManaged = new Set(current.filter((n) => managedSet.has(n)));
+            const add = [...desired].filter((n) => !currentManaged.has(n)).sort();
+            const remove = [...currentManaged].filter((n) => !desired.has(n)).sort();
+            const change = {
+                story_id: storyId,
+                repo: effectiveRepo,
+                issue_number: number,
+                current: [...current].sort(),
+                desired: [...desired].sort(),
+                add,
+                remove,
+            };
+            if (add.length === 0 && remove.length === 0) {
+                outcome.unchanged.push(change);
+                continue;
+            }
+            if (options.dryRun) {
+                outcome.changed.push(change);
+                continue;
+            }
+            try {
+                client.apply(effectiveRepo, number, add, remove);
+            }
+            catch (exc) {
+                outcome.errors.push({ story_id: storyId, message: String(exc) });
+                continue;
+            }
+            outcome.changed.push(change);
+        }
+    }
+    return [outcome.errors.length > 0 ? 1 : 0, outcome];
+}
+export function renderLabelsReport(outcome) {
+    const lines = ["vBRIEF reconcile labels", ""];
+    const suffix = outcome.dry_run ? " (dry-run)" : "";
+    lines.push(`Changed${suffix}:`);
+    if (outcome.changed.length > 0) {
+        for (const change of outcome.changed) {
+            const parts = [];
+            if (change.add.length > 0)
+                parts.push(`+${change.add.join(", +")}`);
+            if (change.remove.length > 0)
+                parts.push(`-${change.remove.join(", -")}`);
+            lines.push(`- #${change.issue_number} (${change.repo}) [${change.story_id}]: ${parts.join("; ")}`);
+        }
+    }
+    else {
+        lines.push("- none");
+    }
+    lines.push("");
+    lines.push("Unchanged:");
+    if (outcome.unchanged.length > 0) {
+        for (const c of outcome.unchanged) {
+            lines.push(`- #${c.issue_number} (${c.repo}) [${c.story_id}]`);
+        }
+    }
+    else {
+        lines.push("- none");
+    }
+    if (outcome.skipped_no_ref.length > 0) {
+        lines.push("");
+        lines.push("Skipped (no github-issue reference / repo):");
+        for (const sid of outcome.skipped_no_ref)
+            lines.push(`- ${sid}`);
+    }
+    if (outcome.errors.length > 0) {
+        lines.push("");
+        lines.push("Errors:");
+        for (const err of outcome.errors)
+            lines.push(`- ${err.story_id}: ${err.message}`);
+    }
+    return lines.join("\n");
+}
+export function labelsOutcomeToJson(outcome) {
+    const toChange = (c) => ({
+        story_id: c.story_id,
+        repo: c.repo,
+        issue_number: c.issue_number,
+        current: [...c.current],
+        desired: [...c.desired],
+        add: [...c.add],
+        remove: [...c.remove],
+    });
+    return {
+        changed: outcome.changed.map(toChange),
+        unchanged: outcome.unchanged.map(toChange),
+        skipped_no_ref: [...outcome.skipped_no_ref],
+        errors: outcome.errors.map((e) => ({ story_id: e.story_id, message: e.message })),
+        dry_run: outcome.dry_run,
+    };
+}
+// Re-export for tests
+export { RESOLVED_FOLDERS };
+//# sourceMappingURL=labels.js.map

package/dist/vbrief-reconcile/main.d.ts

@@ -0,0 +1,18 @@
+export interface CliOptions {
+    projectRoot?: string;
+    repo?: string | null;
+    force?: boolean;
+    dryRun?: boolean;
+    json?: boolean;
+    scenario?: string | null;
+    all?: boolean;
+    fixtureRoot?: string | null;
+}
+export declare function usage(): void;
+export declare function runGraph(opts: CliOptions): number;
+export declare function runLabels(opts: CliOptions): number;
+export declare function runUmbrellas(opts: CliOptions): number;
+export declare function runParityMode(opts: CliOptions): number;
+export declare function run(argv: string[]): number;
+export declare function cmdVbriefReconcile(argv: string[]): number;
+//# sourceMappingURL=main.d.ts.map

package/dist/vbrief-reconcile/main.js

@@ -0,0 +1,149 @@
+import { resolve } from "node:path";
+import { graphOutcomeToJson, reconcileGraph, renderGraphReport } from "./graph.js";
+import { labelsOutcomeToJson, reconcileLabels, renderLabelsReport } from "./labels.js";
+import { PARITY_SCENARIO_NAMES, renderScenarioOutput, runParityScenario, } from "./parity-scenarios.js";
+import { reconcileUmbrellas, renderUmbrellasReport, umbrellasOutcomeToJson } from "./umbrellas.js";
+function parseCommon(argv) {
+    if (argv.length === 0)
+        return { verb: null, rest: [] };
+    const first = argv[0];
+    if (first === "graph" || first === "labels" || first === "umbrellas" || first === "parity") {
+        return { verb: first, rest: argv.slice(1) };
+    }
+    if (first === "--scenario" || first === "--all")
+        return { verb: "parity", rest: argv };
+    return { verb: null, rest: argv };
+}
+function parseOptions(rest) {
+    const opts = { projectRoot: "." };
+    for (let i = 0; i < rest.length; i += 1) {
+        const arg = rest[i];
+        if (arg === "--project-root") {
+            opts.projectRoot = rest[i + 1] ?? ".";
+            i += 1;
+        }
+        else if (arg === "--repo") {
+            opts.repo = rest[i + 1] ?? null;
+            i += 1;
+        }
+        else if (arg === "--force")
+            opts.force = true;
+        else if (arg === "--dry-run")
+            opts.dryRun = true;
+        else if (arg === "--json")
+            opts.json = true;
+        else if (arg === "--scenario") {
+            opts.scenario = rest[i + 1] ?? null;
+            i += 1;
+        }
+        else if (arg === "--all")
+            opts.all = true;
+        else if (arg === "--fixture-root") {
+            opts.fixtureRoot = rest[i + 1] ?? null;
+            i += 1;
+        }
+    }
+    return opts;
+}
+export function usage() {
+    process.stderr.write("usage: vbrief-reconcile <graph|labels|umbrellas> [--project-root PATH] [--dry-run] [--json] [--force] [--repo OWNER/NAME]\n" +
+        "       vbrief-reconcile parity --scenario NAME [--fixture-root PATH]\n" +
+        "       vbrief-reconcile parity --all [--fixture-root PATH]\n");
+}
+export function runGraph(opts) {
+    const root = resolve(opts.projectRoot ?? ".");
+    const [code, outcome] = reconcileGraph(root, { force: opts.force, dryRun: opts.dryRun });
+    if (code === 2) {
+        if (opts.json) {
+            process.stdout.write(`${JSON.stringify({ error: "no vbrief/proposed/ directory found" })}\n`);
+        }
+        else {
+            process.stderr.write(`Error: no vbrief/proposed/ directory found under ${root}\n`);
+        }
+        return 2;
+    }
+    if (opts.json)
+        process.stdout.write(`${JSON.stringify(graphOutcomeToJson(outcome), null, 2)}\n`);
+    else
+        process.stdout.write(`${renderGraphReport(outcome)}\n`);
+    return code;
+}
+export function runLabels(opts) {
+    const root = resolve(opts.projectRoot ?? ".");
+    const [code, outcome] = reconcileLabels(root, { repo: opts.repo, dryRun: opts.dryRun });
+    if (code === 2) {
+        if (opts.json) {
+            process.stdout.write(`${JSON.stringify({ error: "no vbrief/ directory found" })}\n`);
+        }
+        else {
+            process.stderr.write(`Error: no vbrief/ directory found under ${root}\n`);
+        }
+        return 2;
+    }
+    if (opts.json)
+        process.stdout.write(`${JSON.stringify(labelsOutcomeToJson(outcome), null, 2)}\n`);
+    else
+        process.stdout.write(`${renderLabelsReport(outcome)}\n`);
+    return code;
+}
+export function runUmbrellas(opts) {
+    const root = resolve(opts.projectRoot ?? ".");
+    const [code, outcome] = reconcileUmbrellas(root, { repo: opts.repo, dryRun: opts.dryRun });
+    if (code === 2) {
+        if (opts.json) {
+            process.stdout.write(`${JSON.stringify({ error: "no vbrief/ directory found" })}\n`);
+        }
+        else {
+            process.stderr.write(`Error: no vbrief/ directory found under ${root}\n`);
+        }
+        return 2;
+    }
+    if (opts.json)
+        process.stdout.write(`${JSON.stringify(umbrellasOutcomeToJson(outcome), null, 2)}\n`);
+    else
+        process.stdout.write(`${renderUmbrellasReport(outcome)}\n`);
+    return code;
+}
+export function runParityMode(opts) {
+    const root = opts.fixtureRoot ?? process.env.DEFT_VBRIEF_RECONCILE_FIXTURE ?? "/tmp/unset";
+    const names = opts.all ? [...PARITY_SCENARIO_NAMES] : [opts.scenario];
+    const results = names.map((name) => runParityScenario(name, { fixtureRoot: root }));
+    process.stdout.write(renderScenarioOutput(opts.all ? results : results[0]));
+    return 0;
+}
+export function run(argv) {
+    const { verb, rest } = parseCommon(argv);
+    if (verb === null) {
+        usage();
+        return 2;
+    }
+    const opts = parseOptions(rest);
+    switch (verb) {
+        case "graph":
+            return runGraph(opts);
+        case "labels":
+            return runLabels(opts);
+        case "umbrellas":
+            return runUmbrellas(opts);
+        case "parity":
+            if (!opts.all && !opts.scenario) {
+                usage();
+                return 2;
+            }
+            return runParityMode(opts);
+        default:
+            usage();
+            return 2;
+    }
+}
+export function cmdVbriefReconcile(argv) {
+    try {
+        return run(argv);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`vbrief-reconcile: error: ${msg}\n`);
+        return 2;
+    }
+}
+//# sourceMappingURL=main.js.map

package/dist/vbrief-reconcile/parity-scenarios.d.ts

@@ -0,0 +1,16 @@
+import type { LabelClient, UmbrellaClient } from "./types.js";
+export declare const PARITY_SCENARIO_NAMES: readonly ["reconcile-overrides", "reconcile-spec-index", "reconcile-scope-clean", "reconcile-scope-orphan", "reconcile-report", "reconcile-parse-shape", "graph-dry-run", "graph-cycle", "graph-missing-proposed", "labels-blocked-dry-run", "labels-utf8-dry-run", "umbrellas-create-dry-run", "umbrellas-unchanged"];
+export type ParityScenarioName = (typeof PARITY_SCENARIO_NAMES)[number];
+export interface ParityScenarioResult {
+    readonly scenario: string;
+    readonly ok: boolean;
+    readonly payload: unknown;
+}
+export declare function renderScenarioOutput(payload: ParityScenarioResult | ParityScenarioResult[]): string;
+export declare function runParityScenario(name: string, options: {
+    fixtureRoot: string;
+    labelClient?: LabelClient;
+    umbrellaClient?: UmbrellaClient;
+}): ParityScenarioResult;
+export declare function loadFixtureBrief(path: string): Record<string, unknown>;
+//# sourceMappingURL=parity-scenarios.d.ts.map