@deftai/directive 0.125.2 → 0.126.0-beta.2

package/dist/verify-forward-coverage.js

@@ -1,144 +0,0 @@
-#!/usr/bin/env node
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { evaluateForwardCoverage } from "@deftai/directive-core";
-const HELP_TEXT = "Usage: verify-forward-coverage [--project-root <path>] [--staged|--head] [--allow-list <path>]\n" +
-    "                               [--coverage-dir <path>] [--coverage-report <path>]\n" +
-    "                               [--enforce] [--quiet]\n" +
-    "  Fail-closed new-source-file existence (#1310 / #4009) plus warn-first diff coverage of\n" +
-    "  added/modified branches (#3514). Existence correspondence is path-relative and\n" +
-    "  uses the test-boundary policy (#3145); pre-existing tests count. The 90% per-diff\n" +
-    "  threshold is not the 75 global floor. Missing coverage reports skip the diff half.\n" +
-    "  --enforce: fail closed when uncovered changed branches are below 90%.\n";
-function takeValue(argv, i, flag) {
-    const value = argv[i + 1];
-    if (value === undefined) {
-        return { error: `argument ${flag}: expected one argument` };
-    }
-    return { value, next: i + 1 };
-}
-/** Parse the verify-forward-coverage CLI args, mirroring the verify-encoding surface. */
-export function parseArgs(argv) {
-    const parsed = {
-        mode: "head",
-        projectRoot: ".",
-        allowList: null,
-        quiet: false,
-        enforce: false,
-        coverageReport: null,
-        coverageDir: null,
-    };
-    for (let i = 0; i < argv.length; i += 1) {
-        const arg = argv[i];
-        if (arg === "--staged") {
-            parsed.mode = "staged";
-        }
-        else if (arg === "--head") {
-            parsed.mode = "head";
-        }
-        else if (arg === "--quiet") {
-            parsed.quiet = true;
-        }
-        else if (arg === "--enforce") {
-            parsed.enforce = true;
-        }
-        else if (arg === "--help" || arg === "-h") {
-            return { ...parsed, help: true };
-        }
-        else if (arg === "--project-root") {
-            const taken = takeValue(argv, i, "--project-root");
-            if ("error" in taken) {
-                return { ...parsed, error: taken.error };
-            }
-            parsed.projectRoot = taken.value;
-            i = taken.next;
-        }
-        else if (arg?.startsWith("--project-root=")) {
-            parsed.projectRoot = arg.slice("--project-root=".length);
-        }
-        else if (arg === "--allow-list") {
-            const taken = takeValue(argv, i, "--allow-list");
-            if ("error" in taken) {
-                return { ...parsed, error: taken.error };
-            }
-            parsed.allowList = taken.value;
-            i = taken.next;
-        }
-        else if (arg?.startsWith("--allow-list=")) {
-            parsed.allowList = arg.slice("--allow-list=".length);
-        }
-        else if (arg === "--coverage-report") {
-            const taken = takeValue(argv, i, "--coverage-report");
-            if ("error" in taken) {
-                return { ...parsed, error: taken.error };
-            }
-            parsed.coverageReport = taken.value;
-            i = taken.next;
-        }
-        else if (arg?.startsWith("--coverage-report=")) {
-            parsed.coverageReport = arg.slice("--coverage-report=".length);
-        }
-        else if (arg === "--coverage-dir") {
-            const taken = takeValue(argv, i, "--coverage-dir");
-            if ("error" in taken) {
-                return { ...parsed, error: taken.error };
-            }
-            parsed.coverageDir = taken.value;
-            i = taken.next;
-        }
-        else if (arg?.startsWith("--coverage-dir=")) {
-            parsed.coverageDir = arg.slice("--coverage-dir=".length);
-        }
-        else {
-            return { ...parsed, error: `unrecognized argument: ${arg}` };
-        }
-    }
-    return parsed;
-}
-function resolveCoverageReport(args) {
-    if (args.coverageReport !== null) {
-        return resolve(args.coverageReport);
-    }
-    if (args.coverageDir !== null) {
-        return resolve(args.coverageDir, "coverage-final.json");
-    }
-    return undefined;
-}
-/** Run the gate and return the process exit code (argv parse error -> 2). */
-export function run(argv) {
-    const args = parseArgs(argv);
-    if (args.help === true) {
-        process.stdout.write(HELP_TEXT);
-        return 0;
-    }
-    if (args.error !== undefined) {
-        process.stderr.write(`verify_forward_coverage: ${args.error}\n`);
-        return 2;
-    }
-    const projectRoot = resolve(args.projectRoot);
-    const allowListPath = args.allowList !== null ? resolve(args.allowList) : null;
-    const result = evaluateForwardCoverage(projectRoot, {
-        mode: args.mode,
-        allowListPath,
-        enforceDiffCoverage: args.enforce,
-        coverageReportPath: resolveCoverageReport(args),
-    });
-    if (result.exitCode === 0) {
-        if (!args.quiet) {
-            process.stdout.write(`${result.message}\n`);
-        }
-        else if (result.message.includes("ADVISORY")) {
-            process.stdout.write(`${result.message}\n`);
-        }
-    }
-    else {
-        process.stderr.write(`${result.message}\n`);
-    }
-    return result.exitCode;
-}
-// Only execute when invoked directly as a binary (not when imported in tests).
-// Normalize both sides via fileURLToPath so the guard fires on Windows too.
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
-    process.exit(run(process.argv.slice(2)));
-}
-//# sourceMappingURL=verify-forward-coverage.js.map

package/dist/verify-hooks-installed.d.ts

@@ -1,24 +0,0 @@
-#!/usr/bin/env node
-import { type AgentHookHealthResult, type AgentHookReadinessResult, type EvaluateResult, repairAgentHookRegistrations } from "@deftai/directive-core/verify-env";
-type HookScope = "git" | "agent" | "all";
-interface ParsedArgs {
-    projectRoot: string;
-    quiet: boolean;
-    scope: HookScope;
-    live: boolean;
-    repair: boolean;
-    error?: string;
-}
-export interface VerifyHooksInstalledCliSeams {
-    readonly evaluateGit?: (projectRoot: string) => EvaluateResult;
-    readonly evaluateAgent?: (projectRoot: string) => AgentHookHealthResult;
-    readonly evaluateReadiness?: (projectRoot: string) => AgentHookReadinessResult;
-    readonly repairRegistrations?: typeof repairAgentHookRegistrations;
-    readonly writeOut?: (text: string) => void;
-    readonly writeErr?: (text: string) => void;
-}
-export declare function parseArgs(argv: string[]): ParsedArgs;
-/** Verify git hooks, structural agent hooks, or functional agent-hook readiness. */
-export declare function run(argv: string[], seams?: VerifyHooksInstalledCliSeams): number;
-export {};
-//# sourceMappingURL=verify-hooks-installed.d.ts.map

package/dist/verify-hooks-installed.js

@@ -1,140 +0,0 @@
-#!/usr/bin/env node
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { evaluate, evaluateAgentHookReadiness, evaluateAgentHookReadinessSafely, evaluateAgentHooks, formatAgentHookRepairDisposition, repairAgentHookRegistrations, } from "@deftai/directive-core/verify-env";
-export function parseArgs(argv) {
-    const parsed = {
-        projectRoot: ".",
-        quiet: false,
-        scope: "git",
-        live: false,
-        repair: false,
-    };
-    for (let i = 0; i < argv.length; i += 1) {
-        const arg = argv[i];
-        if (arg === "--quiet")
-            parsed.quiet = true;
-        else if (arg === "--live")
-            parsed.live = true;
-        else if (arg === "--repair")
-            parsed.repair = true;
-        else if (arg === "--project-root") {
-            const value = argv[i + 1];
-            if (value === undefined) {
-                return { ...parsed, error: "argument --project-root: expected one argument" };
-            }
-            parsed.projectRoot = value;
-            i += 1;
-        }
-        else if (arg?.startsWith("--project-root=")) {
-            parsed.projectRoot = arg.slice("--project-root=".length);
-        }
-        else if (arg === "--scope") {
-            const value = argv[i + 1];
-            if (value === undefined) {
-                return { ...parsed, error: "argument --scope: expected one argument" };
-            }
-            if (value !== "git" && value !== "agent" && value !== "all") {
-                return { ...parsed, error: `argument --scope: invalid choice: '${value}'` };
-            }
-            parsed.scope = value;
-            i += 1;
-        }
-        else if (arg?.startsWith("--scope=")) {
-            const value = arg.slice("--scope=".length);
-            if (value !== "git" && value !== "agent" && value !== "all") {
-                return { ...parsed, error: `argument --scope: invalid choice: '${value}'` };
-            }
-            parsed.scope = value;
-        }
-        else {
-            return { ...parsed, error: `unrecognized arguments: ${arg}` };
-        }
-    }
-    if (parsed.live && parsed.scope === "git") {
-        return { ...parsed, error: "argument --live requires --scope=agent or --scope=all" };
-    }
-    if (parsed.repair && parsed.scope === "git") {
-        return { ...parsed, error: "argument --repair requires --scope=agent or --scope=all" };
-    }
-    return parsed;
-}
-/** Verify git hooks, structural agent hooks, or functional agent-hook readiness. */
-export function run(argv, seams = {}) {
-    const args = parseArgs(argv);
-    const writeOut = seams.writeOut ?? ((text) => process.stdout.write(text));
-    const writeErr = seams.writeErr ?? ((text) => process.stderr.write(text));
-    if (args.error !== undefined) {
-        writeErr(`${args.error}\n`);
-        return 2;
-    }
-    const projectRoot = resolve(args.projectRoot);
-    const evaluateGit = seams.evaluateGit ?? evaluate;
-    const evaluateAgent = seams.evaluateAgent ?? evaluateAgentHooks;
-    const evaluateReadiness = seams.evaluateReadiness
-        ? (root) => evaluateAgentHookReadinessSafely(root, seams.evaluateReadiness)
-        : evaluateAgentHookReadinessSafely;
-    if (args.repair) {
-        const repair = seams.repairRegistrations ?? repairAgentHookRegistrations;
-        try {
-            let live;
-            const evaluateRepairReadiness = seams.evaluateReadiness
-                ? (root) => evaluateAgentHookReadinessSafely(root, seams.evaluateReadiness)
-                : (root) => evaluateAgentHookReadinessSafely(root, (next) => evaluateAgentHookReadiness(next, { consumerContext: () => true }));
-            const repaired = repair(projectRoot, {
-                reevaluate: (root) => {
-                    live = evaluateRepairReadiness(root);
-                    return live;
-                },
-            });
-            if (live === undefined) {
-                writeErr("agent hook repair refused: live recheck did not run\n");
-                return 2;
-            }
-            if (!args.quiet) {
-                writeOut(`${formatAgentHookRepairDisposition(repaired.written)}\n`);
-                if (live.stream === "stdout")
-                    writeOut(`${live.message}\n`);
-                else
-                    writeErr(`${live.message}\n`);
-            }
-            const gitResults = args.scope === "all" ? [evaluateGit(projectRoot)] : [];
-            if (!args.quiet) {
-                for (const result of gitResults) {
-                    if (result.stream === "stdout")
-                        writeOut(`${result.message}\n`);
-                    else if (result.stream === "stderr")
-                        writeErr(`${result.message}\n`);
-                }
-            }
-            const gitCode = gitResults.length > 0 ? Math.max(...gitResults.map((result) => result.code)) : 0;
-            return Math.max(repaired.after.code, gitCode);
-        }
-        catch (cause) {
-            const detail = cause instanceof Error ? cause.message : String(cause);
-            writeErr(`agent hook repair refused: ${detail}\n`);
-            return 2;
-        }
-    }
-    const results = [
-        ...(args.scope === "git" || args.scope === "all" ? [evaluateGit(projectRoot)] : []),
-        ...(args.scope === "agent" || args.scope === "all"
-            ? [args.live ? evaluateReadiness(projectRoot) : evaluateAgent(projectRoot)]
-            : []),
-    ];
-    if (!args.quiet) {
-        for (const result of results) {
-            if (result.stream === "stdout") {
-                writeOut(`${result.message}\n`);
-            }
-            else if (result.stream === "stderr") {
-                writeErr(`${result.message}\n`);
-            }
-        }
-    }
-    return Math.max(...results.map((result) => result.code));
-}
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
-    process.exit(run(process.argv.slice(2)));
-}
-//# sourceMappingURL=verify-hooks-installed.js.map

package/dist/verify-intent-constraint.d.ts

@@ -1,15 +0,0 @@
-#!/usr/bin/env node
-interface ParsedArgs {
-    projectRoot: string;
-    originRef?: string;
-    staged: boolean;
-    quiet: boolean;
-    planId?: string;
-    error?: string;
-}
-/** Parse verify-intent-constraint CLI args. */
-export declare function parseArgs(argv: string[]): ParsedArgs;
-/** Run the gate and return the process exit code. */
-export declare function run(argv: string[]): number;
-export {};
-//# sourceMappingURL=verify-intent-constraint.d.ts.map

package/dist/verify-intent-constraint.js

@@ -1,86 +0,0 @@
-#!/usr/bin/env node
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { evaluateIntentConstraint } from "@deftai/directive-core/intent-constraint";
-/** Parse verify-intent-constraint CLI args. */
-export function parseArgs(argv) {
-    const parsed = { projectRoot: ".", staged: false, quiet: false };
-    for (let i = 0; i < argv.length; i += 1) {
-        const arg = argv[i];
-        if (arg === "--quiet") {
-            parsed.quiet = true;
-        }
-        else if (arg === "--staged") {
-            parsed.staged = true;
-        }
-        else if (arg === "--project-root") {
-            const value = argv[i + 1];
-            if (value === undefined) {
-                return { ...parsed, error: "argument --project-root: expected one argument" };
-            }
-            parsed.projectRoot = value;
-            i += 1;
-        }
-        else if (arg?.startsWith("--project-root=")) {
-            parsed.projectRoot = arg.slice("--project-root=".length);
-        }
-        else if (arg === "--origin-ref") {
-            const value = argv[i + 1];
-            if (value === undefined) {
-                return { ...parsed, error: "argument --origin-ref: expected one argument" };
-            }
-            parsed.originRef = value;
-            i += 1;
-        }
-        else if (arg?.startsWith("--origin-ref=")) {
-            parsed.originRef = arg.slice("--origin-ref=".length);
-        }
-        else if (arg === "--plan-id") {
-            const value = argv[i + 1];
-            if (value === undefined) {
-                return { ...parsed, error: "argument --plan-id: expected one argument" };
-            }
-            parsed.planId = value;
-            i += 1;
-        }
-        else if (arg?.startsWith("--plan-id=")) {
-            parsed.planId = arg.slice("--plan-id=".length);
-        }
-        else if (arg === "--base-ref") {
-            return {
-                ...parsed,
-                error: "unrecognized argument: --base-ref (baseline is the computed merge base; use --origin-ref to name the origin default)",
-            };
-        }
-        else {
-            return { ...parsed, error: `unrecognized argument: ${arg}` };
-        }
-    }
-    return parsed;
-}
-/** Run the gate and return the process exit code. */
-export function run(argv) {
-    const args = parseArgs(argv);
-    if (args.error !== undefined) {
-        process.stderr.write(`verify_intent_constraint: ${args.error}\n`);
-        return 2;
-    }
-    const result = evaluateIntentConstraint({
-        projectRoot: resolve(args.projectRoot),
-        originRef: args.originRef,
-        staged: args.staged,
-        quiet: args.quiet,
-        planId: args.planId,
-    });
-    if (result.message.length > 0) {
-        if (result.stream === "stdout")
-            process.stdout.write(`${result.message}\n`);
-        else if (result.stream === "stderr")
-            process.stderr.write(`${result.message}\n`);
-    }
-    return result.code;
-}
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
-    process.exit(run(process.argv.slice(2)));
-}
-//# sourceMappingURL=verify-intent-constraint.js.map

package/dist/verify-investigation.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export declare function run(argv: string[]): number;
-//# sourceMappingURL=verify-investigation.d.ts.map

package/dist/verify-investigation.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-import { fileURLToPath } from "node:url";
-import { cmdVerifyInvestigation } from "@deftai/directive-core/orchestration";
-export function run(argv) {
-    return cmdVerifyInvestigation(argv);
-}
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
-    process.exit(run(process.argv.slice(2)));
-}
-//# sourceMappingURL=verify-investigation.js.map

package/dist/verify-judgment-gates.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export declare function run(argv: string[]): number;
-//# sourceMappingURL=verify-judgment-gates.d.ts.map

package/dist/verify-judgment-gates.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-import { fileURLToPath } from "node:url";
-import { cmdVerifyJudgmentGates } from "@deftai/directive-core/orchestration";
-export function run(argv) {
-    return cmdVerifyJudgmentGates(argv);
-}
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
-    process.exit(run(process.argv.slice(2)));
-}
-//# sourceMappingURL=verify-judgment-gates.js.map

package/dist/verify-l4-owner.d.ts

@@ -1,15 +0,0 @@
-#!/usr/bin/env node
-interface ParsedArgs {
-    pr: number | null;
-    projectRoot: string;
-    repo: string | null;
-    headSha: string | null;
-    reviewCycle: string | null;
-    emitJson: boolean;
-    help: boolean;
-    error?: string;
-}
-export declare function parseVerifyL4OwnerArgs(argv: readonly string[]): ParsedArgs;
-export declare function run(argv: readonly string[]): number;
-export {};
-//# sourceMappingURL=verify-l4-owner.d.ts.map

package/dist/verify-l4-owner.js

@@ -1,132 +0,0 @@
-#!/usr/bin/env node
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { evaluateL4OwnerGate, L4_OWNER_HELP, l4OwnerResultToJson, } from "@deftai/directive-core/review-monitor";
-export function parseVerifyL4OwnerArgs(argv) {
-    const acc = {
-        pr: null,
-        projectRoot: ".",
-        repo: null,
-        headSha: null,
-        reviewCycle: null,
-        emitJson: false,
-        help: false,
-    };
-    for (let i = 0; i < argv.length; i += 1) {
-        const arg = argv[i];
-        if (arg === "--help" || arg === "-h") {
-            return { ...acc, help: true };
-        }
-        if (arg === "--json") {
-            acc.emitJson = true;
-        }
-        else if (arg === "--pr") {
-            const value = argv[i + 1];
-            if (value === undefined) {
-                return { ...acc, error: "argument --pr: expected one argument" };
-            }
-            const n = Number(value);
-            if (!Number.isInteger(n) || n <= 0) {
-                return { ...acc, error: `invalid --pr value: ${value}` };
-            }
-            acc.pr = n;
-            i += 1;
-        }
-        else if (arg?.startsWith("--pr=")) {
-            const n = Number(arg.slice("--pr=".length));
-            if (!Number.isInteger(n) || n <= 0) {
-                return { ...acc, error: `invalid --pr value: ${arg}` };
-            }
-            acc.pr = n;
-        }
-        else if (arg === "--repo") {
-            const value = argv[i + 1];
-            if (value === undefined) {
-                return { ...acc, error: "argument --repo: expected one argument" };
-            }
-            acc.repo = value;
-            i += 1;
-        }
-        else if (arg?.startsWith("--repo=")) {
-            acc.repo = arg.slice("--repo=".length);
-        }
-        else if (arg === "--head-sha") {
-            const value = argv[i + 1];
-            if (value === undefined) {
-                return { ...acc, error: "argument --head-sha: expected one argument" };
-            }
-            acc.headSha = value;
-            i += 1;
-        }
-        else if (arg?.startsWith("--head-sha=")) {
-            acc.headSha = arg.slice("--head-sha=".length);
-        }
-        else if (arg === "--project-root") {
-            const value = argv[i + 1];
-            if (value === undefined) {
-                return { ...acc, error: "argument --project-root: expected one argument" };
-            }
-            acc.projectRoot = value;
-            i += 1;
-        }
-        else if (arg?.startsWith("--project-root=")) {
-            acc.projectRoot = arg.slice("--project-root=".length);
-        }
-        else if (arg === "--review-cycle") {
-            const value = argv[i + 1];
-            if (value === undefined) {
-                return { ...acc, error: "argument --review-cycle: expected one argument" };
-            }
-            acc.reviewCycle = value;
-            i += 1;
-        }
-        else if (arg?.startsWith("--review-cycle=")) {
-            acc.reviewCycle = arg.slice("--review-cycle=".length);
-        }
-        else if (arg?.startsWith("-")) {
-            return { ...acc, error: `unrecognized argument: ${arg}` };
-        }
-        else {
-            return { ...acc, error: `unrecognized argument: ${arg}` };
-        }
-    }
-    return acc;
-}
-export function run(argv) {
-    const args = parseVerifyL4OwnerArgs(argv);
-    if (args.help) {
-        process.stdout.write(L4_OWNER_HELP);
-        return 0;
-    }
-    if (args.error !== undefined) {
-        process.stderr.write(`verify_l4_owner: ${args.error}\n`);
-        process.stderr.write("Try: task verify:l4-owner -- --help\n");
-        return 2;
-    }
-    if (args.pr === null) {
-        process.stderr.write("verify_l4_owner: --pr is required\n");
-        process.stderr.write("Try: task verify:l4-owner -- --help\n");
-        return 2;
-    }
-    const result = evaluateL4OwnerGate({
-        pr: args.pr,
-        projectRoot: resolve(args.projectRoot),
-        repo: args.repo,
-        headSha: args.headSha,
-        reviewCycle: args.reviewCycle,
-    });
-    if (args.emitJson) {
-        process.stdout.write(`${JSON.stringify(l4OwnerResultToJson(result), null, 2)}\n`);
-    }
-    else if (result.exitCode === 0) {
-        process.stdout.write(`${result.message}\n`);
-    }
-    else {
-        process.stderr.write(`${result.message}\n`);
-    }
-    return result.exitCode;
-}
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
-    process.exit(run(process.argv.slice(2)));
-}
-//# sourceMappingURL=verify-l4-owner.js.map

package/dist/verify-lifecycle-visible.d.ts

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-interface ParsedArgs {
-    projectRoot: string;
-    enforce: boolean;
-    help?: boolean;
-    error?: string;
-}
-/** Parse verify-lifecycle-visible CLI args (#3505). */
-export declare function parseArgs(argv: string[]): ParsedArgs;
-/** Run the gate and return the process exit code. */
-export declare function run(argv: string[]): number;
-export {};
-//# sourceMappingURL=verify-lifecycle-visible.d.ts.map

package/dist/verify-lifecycle-visible.js

@@ -1,68 +0,0 @@
-#!/usr/bin/env node
-/**
- * CLI for task verify:lifecycle-visible (#3505).
- * Warn-only by default; pass --enforce to fail closed.
- */
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { evaluateLifecycleVisible } from "@deftai/directive-core/lifecycle-visible";
-/** Parse verify-lifecycle-visible CLI args (#3505). */
-export function parseArgs(argv) {
-    const parsed = { projectRoot: ".", enforce: false };
-    for (let i = 0; i < argv.length; i += 1) {
-        const arg = argv[i];
-        if (arg === "--project-root") {
-            const value = argv[i + 1];
-            if (value === undefined) {
-                return { ...parsed, error: "argument --project-root: expected one argument" };
-            }
-            parsed.projectRoot = value;
-            i += 1;
-        }
-        else if (arg?.startsWith("--project-root=")) {
-            parsed.projectRoot = arg.slice("--project-root=".length);
-        }
-        else if (arg === "--enforce") {
-            parsed.enforce = true;
-        }
-        else if (arg === "--help" || arg === "-h") {
-            return { ...parsed, help: true };
-        }
-        else {
-            return { ...parsed, error: `unrecognized argument: ${arg}` };
-        }
-    }
-    return parsed;
-}
-const HELP_TEXT = "Usage: verify-lifecycle-visible [--project-root <path>] [--enforce]\n" +
-    "  Detect ignore/exclude/skip-worktree flags that hide xbrief/vbrief lifecycle roots (#3505).\n" +
-    "  Default: warn-only (exit 0 with advisory report).\n" +
-    "  --enforce: fail closed (exit 1) when a lifecycle root is hidden.\n" +
-    "  Not part of task check — per-clone property, wired from session:start.\n";
-/** Run the gate and return the process exit code. */
-export function run(argv) {
-    const args = parseArgs(argv);
-    if (args.help === true) {
-        process.stdout.write(HELP_TEXT);
-        return 0;
-    }
-    if (args.error !== undefined) {
-        process.stderr.write(`verify_lifecycle_visible: ${args.error}\n`);
-        return 2;
-    }
-    const result = evaluateLifecycleVisible({
-        projectRoot: resolve(args.projectRoot),
-        enforce: args.enforce,
-    });
-    if (result.stream === "stdout") {
-        process.stdout.write(`${result.message}\n`);
-    }
-    else {
-        process.stderr.write(`${result.message}\n`);
-    }
-    return result.code;
-}
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
-    process.exit(run(process.argv.slice(2)));
-}
-//# sourceMappingURL=verify-lifecycle-visible.js.map