@deftai/directive 0.126.0-beta.2 → 0.126.1

package/dist/triage-welcome.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { interceptHelp } from "@deftai/directive-core/dist/triage/help/index.js";
+import { runDefaultMode } from "@deftai/directive-core/dist/triage/welcome/default-mode.js";
+import { runOnboardMode } from "@deftai/directive-core/dist/triage/welcome/onboard.js";
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: process.env.DEFT_PROJECT_ROOT ?? ".",
+        onboard: false,
+        noHistory: false,
+        taskPrefix: process.env.DEFT_TASK_PREFIX ?? "",
+        preset: null,
+        wipCap: null,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--onboard")
+            parsed.onboard = true;
+        else if (arg === "--no-history")
+            parsed.noHistory = true;
+        else if (arg === "--preset") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --preset: expected one argument" };
+            parsed.preset = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--preset=")) {
+            const value = arg.slice("--preset=".length);
+            if (value === "")
+                return { ...parsed, error: "argument --preset: expected one argument" };
+            parsed.preset = value;
+        }
+        else if (arg === "--wip-cap") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --wip-cap: expected one argument" };
+            const parsedCap = Number(value);
+            if (!Number.isInteger(parsedCap))
+                return { ...parsed, error: `argument --wip-cap: expected an integer, got ${value}` };
+            parsed.wipCap = parsedCap;
+            i += 1;
+        }
+        else if (arg?.startsWith("--wip-cap=")) {
+            const value = arg.slice("--wip-cap=".length);
+            const parsedCap = Number(value);
+            if (!Number.isInteger(parsedCap))
+                return { ...parsed, error: `argument --wip-cap: expected an integer, got ${value}` };
+            parsed.wipCap = parsedCap;
+        }
+        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 === "--task-prefix") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --task-prefix: expected one argument" };
+            parsed.taskPrefix = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--task-prefix=")) {
+            parsed.taskPrefix = arg.slice("--task-prefix=".length);
+        }
+        else if (arg === "--no-subprocess" || arg === "--skip-bootstrap") {
+            // accepted for argparse parity; default mode ignores them
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+export function run(argv) {
+    const helpRc = interceptHelp("triage_welcome", argv);
+    if (helpRc !== null) {
+        return helpRc;
+    }
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`triage:welcome: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    try {
+        if (!statSync(projectRoot).isDirectory()) {
+            process.stderr.write(`triage:welcome: --project-root ${projectRoot} is not a directory.\n`);
+            return 2;
+        }
+    }
+    catch {
+        process.stderr.write(`triage:welcome: --project-root ${projectRoot} is not a directory.\n`);
+        return 2;
+    }
+    if (args.onboard) {
+        const onboardOutcome = runOnboardMode(projectRoot, {
+            preset: args.preset,
+            wipCap: args.wipCap,
+            writeHistory: !args.noHistory,
+            taskPrefix: args.taskPrefix || null,
+        });
+        return onboardOutcome.exitCode;
+    }
+    const outcome = runDefaultMode(projectRoot, {
+        writeHistory: !args.noHistory,
+        taskPrefix: args.taskPrefix || null,
+    });
+    return outcome.exitCode;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=triage-welcome.js.map

package/dist/ts-check-lane.d.ts

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

package/dist/ts-check-lane.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+/**
+ * ts-check-lane.ts -- CLI for the Node-toolchain-aware TS lane (#1530, #1790).
+ *
+ * Usage:
+ *   deft-ts ts-check-lane --project-root <path>
+ *
+ * Thin shim -- delegates to @deftai/directive-core/ts-check-lane.
+ */
+import { fileURLToPath } from "node:url";
+import { resolvePnpm, runTsLane } from "@deftai/directive-core/ts-check-lane";
+export function parseArgs(argv) {
+    const parsed = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i] ?? "";
+        if (arg === "--project-root") {
+            const next = argv[i + 1];
+            if (next === undefined)
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            parsed.projectRoot = next;
+            i++;
+        }
+        else if (arg.startsWith("--project-root=")) {
+            const value = arg.slice("--project-root=".length);
+            if (value === "")
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            parsed.projectRoot = value;
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`ts-check-lane: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = args.projectRoot ?? ".";
+    return runTsLane(projectRoot, { pnpm: resolvePnpm() });
+}
+/* v8 ignore start -- entry guard */
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+/* v8 ignore stop */
+//# sourceMappingURL=ts-check-lane.js.map

package/dist/umbrella-current-shape.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+export interface ParsedUmbrellaCurrentShapeArgs {
+    projectRoot: string;
+    passthrough: string[];
+    error?: string;
+}
+export declare function parseArgs(argv: readonly string[]): ParsedUmbrellaCurrentShapeArgs;
+export declare function run(argv: readonly string[]): number;
+//# sourceMappingURL=umbrella-current-shape.d.ts.map

package/dist/umbrella-current-shape.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { parseCurrentShapeArgv, runCurrentShape, } from "@deftai/directive-core/umbrella-current-shape";
+export function parseArgs(argv) {
+    let projectRoot = process.cwd();
+    const passthrough = [];
+    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 {
+                    projectRoot,
+                    passthrough,
+                    error: "argument --project-root: expected one argument",
+                };
+            }
+            projectRoot = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--project-root=")) {
+            projectRoot = arg.slice("--project-root=".length);
+        }
+        else {
+            passthrough.push(arg);
+        }
+    }
+    return { projectRoot, passthrough };
+}
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`umbrella:current-shape: ${args.error}\n`);
+        return 2;
+    }
+    const parsed = parseCurrentShapeArgv(args.passthrough);
+    if (parsed.passthroughError !== undefined) {
+        process.stderr.write(`umbrella:current-shape: ${parsed.passthroughError}\n`);
+        return 2;
+    }
+    if (parsed.issueNumber === null) {
+        process.stderr.write("umbrella:current-shape: issue number required\n");
+        return 2;
+    }
+    return runCurrentShape({
+        issueNumber: parsed.issueNumber,
+        projectRoot: args.projectRoot,
+        repo: parsed.repo,
+        jsonMode: parsed.jsonMode,
+        strict: parsed.strict,
+    });
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=umbrella-current-shape.js.map

package/dist/vbrief-activate.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=vbrief-activate.d.ts.map

package/dist/vbrief-activate.js

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

package/dist/vbrief-build.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=vbrief-build.d.ts.map

package/dist/vbrief-build.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/** Thin CLI seam for vbrief-build parity scenarios (#1782 s1). */
+import { fileURLToPath } from "node:url";
+import { cmdVbriefBuild } from "@deftai/directive-core/vbrief-build";
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(cmdVbriefBuild(process.argv.slice(2)));
+}
+//# sourceMappingURL=vbrief-build.js.map

package/dist/vbrief-preflight-fixtures.d.ts

@@ -0,0 +1,32 @@
+export interface JsonGateOutput {
+    readonly exitCode: number;
+    readonly ready: boolean;
+    readonly vbriefPath: string;
+    readonly message: string;
+    readonly rawJson: string;
+}
+export interface ParityCaseResult {
+    readonly name: string;
+    readonly ok: boolean;
+    readonly pythonExit: number;
+    readonly tsExit: number;
+    readonly exitMismatch: boolean;
+    readonly messageMismatch: boolean;
+    readonly readyMismatch: boolean;
+}
+export interface ParityResult {
+    readonly ok: boolean;
+    readonly cases: ParityCaseResult[];
+}
+/** Fixture corpus: [label, folder, file content]. */
+export declare const PARITY_FIXTURES: ReadonlyArray<readonly [string, string, string]>;
+/** Parse the structured `--json` stdout payload. */
+export declare function parseJsonOutput(stdout: string, exitCode: number): JsonGateOutput;
+/** Diff two gate JSON outputs for one fixture case. */
+export declare function diffOutputs(name: string, python: JsonGateOutput, ts: JsonGateOutput): ParityCaseResult;
+/** Build temp fixture files; returns map of label -> absolute path. */
+export declare function buildFixtures(root: string): Map<string, string>;
+/** Run both gates against all fixtures and diff them. */
+/** Render a human-readable parity report (exported for unit tests). */
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=vbrief-preflight-fixtures.d.ts.map

package/dist/vbrief-preflight-fixtures.js

@@ -0,0 +1,79 @@
+/** Test fixtures extracted from legacy parity harness (#2083). */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+/** Fixture corpus: [label, folder, file content]. */
+export const PARITY_FIXTURES = [
+    ["active_running", "active", JSON.stringify({ plan: { status: "running" } })],
+    ["pending", "pending", JSON.stringify({ plan: { status: "running" } })],
+    ["proposed", "proposed", JSON.stringify({ plan: { status: "running" } })],
+    ["malformed_json", "active", "{bad json"],
+    ["wrong_status", "active", JSON.stringify({ plan: { status: "pending" } })],
+    ["missing_plan_status", "active", JSON.stringify({ plan: {} })],
+];
+/** Parse the structured `--json` stdout payload. */
+export function parseJsonOutput(stdout, exitCode) {
+    const trimmed = stdout.trim();
+    let payload;
+    try {
+        payload = JSON.parse(trimmed);
+    }
+    catch {
+        throw new Error(`Expected JSON output but got: ${trimmed.length > 0 ? trimmed : "(empty)"}`);
+    }
+    return {
+        exitCode,
+        ready: payload.ready,
+        vbriefPath: payload.vbrief_path,
+        message: payload.message,
+        rawJson: trimmed,
+    };
+}
+/** Diff two gate JSON outputs for one fixture case. */
+export function diffOutputs(name, python, ts) {
+    const exitMismatch = python.exitCode !== ts.exitCode;
+    const readyMismatch = python.ready !== ts.ready;
+    const messageMismatch = python.message !== ts.message;
+    return {
+        name,
+        ok: !exitMismatch && !readyMismatch && !messageMismatch,
+        pythonExit: python.exitCode,
+        tsExit: ts.exitCode,
+        exitMismatch,
+        readyMismatch,
+        messageMismatch,
+    };
+}
+/** Build temp fixture files; returns map of label -> absolute path. */
+export function buildFixtures(root) {
+    const paths = new Map();
+    for (const [label, folder, content] of PARITY_FIXTURES) {
+        const dir = join(root, folder);
+        mkdirSync(dir, { recursive: true });
+        const file = join(dir, `${label}.xbrief.json`);
+        writeFileSync(file, content, { encoding: "utf8" });
+        paths.set(label, file);
+    }
+    return paths;
+}
+/** Run both gates against all fixtures and diff them. */
+/** Render a human-readable parity report (exported for unit tests). */
+export function renderReport(result) {
+    if (result.ok) {
+        return `vbrief_preflight parity: CLEAN -- Python and TS agree on ${result.cases.length} fixture(s).`;
+    }
+    const lines = ["vbrief_preflight parity: DIVERGENCE"];
+    for (const c of result.cases.filter((x) => !x.ok)) {
+        lines.push(`  case ${c.name}:`);
+        if (c.exitMismatch) {
+            lines.push(`    exit mismatch: python=${c.pythonExit} ts=${c.tsExit}`);
+        }
+        if (c.readyMismatch) {
+            lines.push("    ready mismatch");
+        }
+        if (c.messageMismatch) {
+            lines.push("    message mismatch");
+        }
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=vbrief-preflight-fixtures.js.map

package/dist/vbrief-preflight.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    vbriefPath: string | null;
+    emitJson: boolean;
+    help?: boolean;
+    error?: string;
+}
+/** Parse vbrief-preflight / xbrief:preflight CLI args (#810 / #2449). */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run the gate and return the process exit code (parse errors -> 2). */
+export declare function run(argv: string[], scan?: (briefPath: string) => readonly string[]): number;
+export {};
+//# sourceMappingURL=vbrief-preflight.d.ts.map

package/dist/vbrief-preflight.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { emitJson, evaluate, PREFLIGHT_USAGE_HINT } from "@deftai/directive-core/preflight";
+import { scanWorkClaimForBriefPath } from "@deftai/directive-core/scm";
+import { refuseIfWslOwnershipBlocked } from "./wsl-ownership-guard.js";
+const HELP_TEXT = `usage: xbrief:preflight [--vbrief-path PATH | PATH] [--json] [--help]
+
+Implementation-intent gate (#810): exits 0 only when the xBRIEF is in
+xbrief/active/ (or legacy vbrief/active/) AND plan.status == 'running'.
+
+Examples:
+  deft xbrief:preflight -- xbrief/active/<story>.xbrief.json
+  deft xbrief:preflight --vbrief-path xbrief/active/<story>.xbrief.json
+`;
+const PATH_FLAG_NAMES = ["--vbrief-path", "--brief-path", "--xbrief-path"];
+function assignPathFlag(parsed, value) {
+    if (value === undefined || value.length === 0) {
+        return { ...parsed, error: "argument --vbrief-path: expected one argument" };
+    }
+    if (parsed.vbriefPath !== null) {
+        return { ...parsed, error: "multiple path arguments are not allowed" };
+    }
+    return { ...parsed, vbriefPath: value };
+}
+/** Parse vbrief-preflight / xbrief:preflight CLI args (#810 / #2449). */
+export function parseArgs(argv) {
+    const parsed = {
+        vbriefPath: null,
+        emitJson: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--") {
+            continue;
+        }
+        if (arg === "--json") {
+            parsed.emitJson = true;
+            continue;
+        }
+        if (arg === "--help" || arg === "-h") {
+            return { ...parsed, help: true };
+        }
+        if (PATH_FLAG_NAMES.includes(arg)) {
+            // Task wrappers bake `--vbrief-path {{.CLI_ARGS}}`, so
+            // `task xbrief:preflight -- --help` arrives as `--vbrief-path --help`.
+            const nextToken = argv[i + 1];
+            if (nextToken === "--help" || nextToken === "-h") {
+                return { ...parsed, help: true };
+            }
+            if (nextToken?.startsWith("-")) {
+                return {
+                    ...parsed,
+                    error: "argument --vbrief-path: expected one argument",
+                };
+            }
+            const next = assignPathFlag(parsed, nextToken);
+            if (next?.error !== undefined)
+                return next;
+            parsed.vbriefPath = next?.vbriefPath ?? null;
+            i += 1;
+            continue;
+        }
+        let matchedEqualsForm = false;
+        for (const flag of PATH_FLAG_NAMES) {
+            if (arg?.startsWith(`${flag}=`)) {
+                const next = assignPathFlag(parsed, arg.slice(flag.length + 1));
+                if (next?.error !== undefined)
+                    return next;
+                parsed.vbriefPath = next?.vbriefPath ?? null;
+                matchedEqualsForm = true;
+                break;
+            }
+        }
+        if (matchedEqualsForm)
+            continue;
+        if (arg?.startsWith("-")) {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+        const next = assignPathFlag(parsed, arg);
+        if (next?.error !== undefined)
+            return next;
+        parsed.vbriefPath = next?.vbriefPath ?? null;
+    }
+    if (parsed.vbriefPath === null) {
+        return {
+            ...parsed,
+            error: `the following arguments are required: --vbrief-path (or positional path). ${PREFLIGHT_USAGE_HINT}`,
+        };
+    }
+    return parsed;
+}
+/** Run the gate and return the process exit code (parse errors -> 2). */
+export function run(argv, scan = scanWorkClaimForBriefPath) {
+    const args = parseArgs(argv);
+    if (args.help) {
+        process.stdout.write(HELP_TEXT);
+        return 0;
+    }
+    if (args.error !== undefined) {
+        process.stderr.write(`preflight_implementation: ${args.error}\n`);
+        return 2;
+    }
+    const vbriefPath = args.vbriefPath;
+    // #1617: gate the brief's tree, not process.cwd() (cross-directory callers).
+    const blocked = refuseIfWslOwnershipBlocked(dirname(resolve(vbriefPath)));
+    if (blocked !== null)
+        return blocked;
+    const result = evaluate(vbriefPath);
+    let scanLines = [];
+    try {
+        scanLines = [...scan(vbriefPath)];
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        scanLines = [
+            `[deft work-claim] warning: scan failed (${message}). Warn is success; this is not a GitHub lock.`,
+        ];
+    }
+    if (args.emitJson) {
+        const message = scanLines.length > 0 ? `${result.message}\n${scanLines.join("\n")}` : result.message;
+        process.stdout.write(`${emitJson(vbriefPath, result.exitCode, message)}\n`);
+    }
+    else if (result.exitCode === 0) {
+        process.stdout.write(`${result.message}\n`);
+        for (const line of scanLines) {
+            process.stdout.write(`${line}\n`);
+        }
+    }
+    else {
+        process.stderr.write(`${result.message}\n`);
+        for (const line of scanLines) {
+            process.stderr.write(`${line}\n`);
+        }
+    }
+    return result.exitCode;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=vbrief-preflight.js.map

package/dist/vbrief-reconcile.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=vbrief-reconcile.d.ts.map

package/dist/vbrief-reconcile.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { cmdVbriefReconcile } from "@deftai/directive-core/vbrief-reconcile";
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(cmdVbriefReconcile(process.argv.slice(2)));
+}
+//# sourceMappingURL=vbrief-reconcile.js.map

package/dist/vbrief-validate.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=vbrief-validate.d.ts.map

package/dist/vbrief-validate.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/** Thin CLI seam for vbrief:validate + verify:vbrief-conformance (#1782 s3). */
+import { fileURLToPath } from "node:url";
+import { cmdVbriefValidate } from "@deftai/directive-core/vbrief-validate";
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(cmdVbriefValidate(process.argv.slice(2)));
+}
+//# sourceMappingURL=vbrief-validate.js.map

package/dist/vbrief-validation.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=vbrief-validation.d.ts.map

package/dist/vbrief-validation.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/** Thin CLI seam for vbrief-validation parity scenarios (#1782 s2). */
+import { fileURLToPath } from "node:url";
+import { cmdVbriefValidation } from "@deftai/directive-core/vbrief-validation";
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(cmdVbriefValidation(process.argv.slice(2)));
+}
+//# sourceMappingURL=vbrief-validation.js.map

package/dist/verify-ac.d.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    xbriefPath: string | null;
+    quiet: boolean;
+    captureOnly: boolean;
+    softMissingXbrief: boolean;
+    error?: string;
+}
+/** Parse verify:ac CLI args. */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Result of scanning lifecycle active/ for scope artifacts. */
+export type FindActiveXbriefResult = {
+    readonly kind: "one";
+    readonly path: string;
+} | {
+    readonly kind: "none";
+} | {
+    readonly kind: "many";
+    readonly paths: readonly string[];
+    readonly dir: string;
+};
+/** Three-state exit: pass=0, fail=1, config=2. A printed pass must not leak 201. */
+export declare function clampVerifyAcExit(ok: boolean, code: number): number;
+/** Run the gate and return the process exit code. */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=verify-ac.d.ts.map