@deftai/directive 0.126.0-beta.2 → 0.126.0

package/dist/verify-branch.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluate } from "@deftai/directive-core/branch";
+/** Parse verify-branch CLI args, mirroring the Python argparse surface. */
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        allowMissingProjectDefinition: false,
+        defaultBranches: null,
+        quiet: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--allow-missing-project-definition") {
+            parsed.allowMissingProjectDefinition = true;
+        }
+        else if (arg === "--quiet") {
+            parsed.quiet = 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 === "--default-branch") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --default-branch: expected one argument" };
+            }
+            if (parsed.defaultBranches === null) {
+                parsed.defaultBranches = [];
+            }
+            parsed.defaultBranches.push(value);
+            i += 1;
+        }
+        else if (arg?.startsWith("--default-branch=")) {
+            if (parsed.defaultBranches === null) {
+                parsed.defaultBranches = [];
+            }
+            parsed.defaultBranches.push(arg.slice("--default-branch=".length));
+        }
+        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(`preflight_branch: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const defaultBranches = args.defaultBranches !== null ? new Set(args.defaultBranches) : undefined;
+    const result = evaluate(projectRoot, {
+        allowMissingProjectDefinition: args.allowMissingProjectDefinition,
+        defaultBranches,
+    });
+    if (result.exitCode === 0) {
+        if (!args.quiet) {
+            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-branch.js.map

package/dist/verify-class-checks.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    baseRef: string | null;
+    quiet: boolean;
+    error?: string;
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=verify-class-checks.d.ts.map

package/dist/verify-class-checks.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/**
+ * CLI for verify:class-checks (#4980 / #3145 class).
+ */
+import { resolve } from "node:path";
+import { classChecks } from "@deftai/directive-core";
+import { isDirectEntrypoint } from "./entrypoint.js";
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        baseRef: null,
+        quiet: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--quiet") {
+            parsed.quiet = 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 === "--base-ref") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --base-ref: expected one argument" };
+            }
+            parsed.baseRef = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--base-ref=")) {
+            parsed.baseRef = arg.slice("--base-ref=".length);
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`verify_class_checks: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const result = classChecks.evaluateClassChecks(projectRoot, {
+        baseRef: args.baseRef,
+        quiet: args.quiet,
+    });
+    if (result.exitCode === 0) {
+        if (!args.quiet) {
+            process.stdout.write(`${result.message}\n`);
+        }
+    }
+    else {
+        process.stderr.write(`${result.message}\n`);
+    }
+    return result.exitCode;
+}
+if (isDirectEntrypoint(import.meta.url)) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-class-checks.js.map

package/dist/verify-cohort-review-monitors.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { parseCohortReviewMonitorsArgv, verifyCohortReviewMonitorsMain } from "@deftai/directive-core/swarm";
+export { parseCohortReviewMonitorsArgv, verifyCohortReviewMonitorsMain };
+export declare function run(argv?: readonly string[]): number;
+//# sourceMappingURL=verify-cohort-review-monitors.d.ts.map

package/dist/verify-cohort-review-monitors.js

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

package/dist/verify-completed-tracked.d.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    repo: string | null;
+    tip: string | null;
+    issue: number | null;
+    quiet: boolean;
+    skipGh: boolean;
+    /** Opt-in discovery when --issue is set; unscoped defaults to on (#3495). */
+    discover: boolean | null;
+    enforce: boolean;
+    error?: string;
+}
+/** Parse verify-completed-tracked CLI args (#3264 / #3476 / #3495). */
+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-completed-tracked.d.ts.map

package/dist/verify-completed-tracked.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { COMPLETED_TRACKED_PROGRESS_MIN_BLOBS, COMPLETED_TRACKED_PROGRESS_THRESHOLD_MS, evaluateCompletedTracked, evaluateShippedClosedDiscovery, shouldAnnounceProgress, shouldAnnounceUpFrontCount, } from "@deftai/directive-core/lifecycle";
+function parseIssueNumber(raw) {
+    const trimmed = raw.startsWith("#") ? raw.slice(1) : raw;
+    if (!/^\d+$/.test(trimmed)) {
+        return null;
+    }
+    const value = Number(trimmed);
+    return Number.isInteger(value) && value > 0 ? value : null;
+}
+/** Parse verify-completed-tracked CLI args (#3264 / #3476 / #3495). */
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        repo: null,
+        tip: null,
+        issue: null,
+        quiet: false,
+        skipGh: false,
+        discover: null,
+        enforce: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--quiet") {
+            parsed.quiet = true;
+        }
+        else if (arg === "--skip-gh") {
+            parsed.skipGh = true;
+        }
+        else if (arg === "--discover") {
+            parsed.discover = true;
+        }
+        else if (arg === "--no-discover") {
+            parsed.discover = false;
+        }
+        else if (arg === "--enforce") {
+            parsed.enforce = 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 === "--repo") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --repo: expected one argument" };
+            }
+            parsed.repo = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--repo=")) {
+            parsed.repo = arg.slice("--repo=".length);
+        }
+        else if (arg === "--tip") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --tip: expected one argument" };
+            }
+            parsed.tip = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--tip=")) {
+            parsed.tip = arg.slice("--tip=".length);
+        }
+        else if (arg === "--issue") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --issue: expected one argument" };
+            }
+            const issue = parseIssueNumber(value);
+            if (issue === null) {
+                return { ...parsed, error: `argument --issue: expected a positive integer, got ${value}` };
+            }
+            parsed.issue = issue;
+            i += 1;
+        }
+        else if (arg?.startsWith("--issue=")) {
+            const value = arg.slice("--issue=".length);
+            const issue = parseIssueNumber(value);
+            if (issue === null) {
+                return { ...parsed, error: `argument --issue: expected a positive integer, got ${value}` };
+            }
+            parsed.issue = issue;
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+function shouldRunDiscovery(args) {
+    if (args.discover === false) {
+        return false;
+    }
+    if (args.discover === true || args.enforce) {
+        return true;
+    }
+    // Warn-first default: unscoped corpus scans discover; --issue N stays land-only.
+    return args.issue === null;
+}
+/** 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_completed_tracked: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const thresholdMs = resolveProgressThresholdMs();
+    let announced = false;
+    const land = evaluateCompletedTracked(projectRoot, {
+        quiet: args.quiet,
+        repo: args.repo,
+        tip: args.tip,
+        issue: args.issue,
+        skipGh: args.skipGh,
+        onProgress: (event) => {
+            if (args.quiet || announced) {
+                return;
+            }
+            const minBlobs = resolveProgressMinBlobs();
+            const upFront = event.phase === "listed" &&
+                shouldAnnounceUpFrontCount(event.terminalCount, event.nonterminalCount, minBlobs);
+            if (!upFront && !shouldAnnounceProgress(event.elapsedMs, thresholdMs)) {
+                return;
+            }
+            announced = true;
+            writeProgress(event);
+        },
+    });
+    let discoveryCode = 0;
+    let discoveryMessage = "";
+    let discoveryStream = "none";
+    if (shouldRunDiscovery(args)) {
+        const discovery = evaluateShippedClosedDiscovery(projectRoot, {
+            quiet: args.quiet,
+            repo: args.repo,
+            tip: args.tip,
+            skipGh: args.skipGh,
+            enforce: args.enforce,
+        });
+        discoveryCode = discovery.code;
+        discoveryMessage = discovery.message;
+        discoveryStream = discovery.stream;
+    }
+    // Scoped land fail-closed must not be softened by discovery warn (#3495 Reject).
+    if (land.message.length > 0) {
+        if (land.stream === "stdout") {
+            process.stdout.write(`${land.message}\n`);
+        }
+        else if (land.stream === "stderr") {
+            process.stderr.write(`${land.message}\n`);
+        }
+    }
+    if (discoveryMessage.length > 0) {
+        if (discoveryStream === "stdout") {
+            process.stdout.write(`${discoveryMessage}\n`);
+        }
+        else if (discoveryStream === "stderr") {
+            process.stderr.write(`${discoveryMessage}\n`);
+        }
+    }
+    if (land.code === 2 || discoveryCode === 2) {
+        return 2;
+    }
+    if (land.code === 1 || discoveryCode === 1) {
+        return 1;
+    }
+    return 0;
+}
+function resolveProgressThresholdMs() {
+    const raw = process.env.DEFT_COMPLETED_TRACKED_PROGRESS_MS;
+    if (raw !== undefined && /^\d+$/.test(raw)) {
+        return Number(raw);
+    }
+    return COMPLETED_TRACKED_PROGRESS_THRESHOLD_MS;
+}
+function resolveProgressMinBlobs() {
+    const raw = process.env.DEFT_COMPLETED_TRACKED_PROGRESS_MIN_BLOBS;
+    if (raw !== undefined && /^\d+$/.test(raw)) {
+        return Number(raw);
+    }
+    return COMPLETED_TRACKED_PROGRESS_MIN_BLOBS;
+}
+function writeProgress(event) {
+    process.stderr.write(`verify:completed-tracked: still running (${event.elapsedMs}ms); ` +
+        `reading ${event.terminalCount} terminal and ${event.nonterminalCount} nonterminal blobs.\n`);
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-completed-tracked.js.map

package/dist/verify-completed-write-guard.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    baseRef: string;
+    quiet: boolean;
+    error?: string;
+}
+/** Parse verify-completed-write-guard CLI args (#3679). */
+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-completed-write-guard.d.ts.map

package/dist/verify-completed-write-guard.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+/**
+ * CLI for verify:completed-write-guard (#3679).
+ */
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluateCompletedWriteGuard } from "@deftai/directive-core/lifecycle";
+/** Parse verify-completed-write-guard CLI args (#3679). */
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        baseRef: "",
+        quiet: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--quiet") {
+            parsed.quiet = 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 === "--base-ref") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --base-ref: expected one argument" };
+            }
+            parsed.baseRef = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--base-ref=")) {
+            parsed.baseRef = arg.slice("--base-ref=".length);
+        }
+        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_completed_write_guard: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const result = evaluateCompletedWriteGuard(projectRoot, {
+        ...(args.baseRef.length > 0 ? { baseRef: args.baseRef } : {}),
+        runGh: (command) => {
+            const proc = spawnSync(command[0] ?? "gh", command.slice(1), {
+                cwd: projectRoot,
+                encoding: "utf8",
+                timeout: 15_000,
+            });
+            return {
+                returncode: proc.status ?? 1,
+                stdout: proc.stdout ?? "",
+            };
+        },
+    });
+    if (result.message.length > 0 && !args.quiet) {
+        if (result.code === 0) {
+            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-completed-write-guard.js.map

package/dist/verify-consumer-check-contract.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    frameworkSource: boolean;
+    enforce: boolean;
+    quiet: boolean;
+    error?: string;
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=verify-consumer-check-contract.d.ts.map

package/dist/verify-consumer-check-contract.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * CLI for verify:consumer-check-contract (#3145).
+ */
+import { resolve } from "node:path";
+import { consumerCheckContract } from "@deftai/directive-core";
+import { isDirectEntrypoint } from "./entrypoint.js";
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        frameworkSource: false,
+        enforce: true,
+        quiet: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--quiet") {
+            parsed.quiet = true;
+        }
+        else if (arg === "--enforce") {
+            parsed.enforce = true;
+        }
+        else if (arg === "--warn") {
+            parsed.enforce = false;
+        }
+        else if (arg === "--framework-source") {
+            parsed.frameworkSource = 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 {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`verify_consumer_check_contract: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const result = consumerCheckContract.evaluateConsumerCheckContract(projectRoot, {
+        frameworkSource: args.frameworkSource,
+        enforce: args.enforce,
+    });
+    if (result.exitCode === 0) {
+        if (!args.quiet) {
+            process.stdout.write(`${result.message}\n`);
+        }
+    }
+    else {
+        process.stderr.write(`${result.message}\n`);
+    }
+    return result.exitCode;
+}
+if (isDirectEntrypoint(import.meta.url)) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-consumer-check-contract.js.map

package/dist/verify-consumer-header-placeholder.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    quiet: boolean;
+    error?: string;
+}
+/** Parse verify-consumer-header-placeholder 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-consumer-header-placeholder.d.ts.map

package/dist/verify-consumer-header-placeholder.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * CLI for verify:consumer-header-placeholder (#4544 Prefer-A).
+ *
+ * Fail closed when product-mutation completion still leaves the unmanaged
+ * AGENTS.md header on the exact scaffold edit-me placeholder. Process-only
+ * and custom headers pass. Returned failure only.
+ */
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluateConsumerHeaderPlaceholderAtRoot } from "@deftai/directive-core/check";
+function takeProjectRootValue(argv, index) {
+    const next = argv[index + 1];
+    if (next === undefined || next.length === 0 || next.startsWith("-")) {
+        return { error: "argument --project-root: expected one argument", next: index };
+    }
+    return { value: next, next: index + 1 };
+}
+/** Parse verify-consumer-header-placeholder CLI args. */
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        quiet: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--quiet") {
+            parsed.quiet = true;
+        }
+        else if (arg === "--project-root") {
+            const taken = takeProjectRootValue(argv, i);
+            if (taken.error !== undefined) {
+                return { ...parsed, error: taken.error };
+            }
+            parsed.projectRoot = taken.value ?? parsed.projectRoot;
+            i = taken.next;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            const value = arg.slice("--project-root=".length);
+            if (value.length === 0 || value.startsWith("-")) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+        }
+        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_consumer_header_placeholder: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const result = evaluateConsumerHeaderPlaceholderAtRoot(projectRoot);
+    if (result.message.length > 0 && !args.quiet) {
+        if (result.ok) {
+            process.stdout.write(`${result.message}\n`);
+        }
+        else {
+            process.stderr.write(`${result.message}\n`);
+        }
+    }
+    return result.ok ? 0 : 1;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-consumer-header-placeholder.js.map

package/dist/verify-consumer-test-lane.d.ts

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