@deftai/directive-core 0.61.2 → 0.63.0

package/dist/render/framework-commands.js

@@ -1,6 +1,7 @@
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { cmdDoctor } from "../doctor/main.js";
 function spec(name, entrypoint, opts = {}) {
     return { name, entrypoint, ...opts };
@@ -12,8 +13,6 @@ export const COMMANDS = {
     "core:validate": spec("core:validate", "framework_commands:_cmd_core_validate", {
         cwd: "framework",
     }),
-    "core:lint": spec("core:lint", "framework_commands:_cmd_core_lint", { cwd: "framework" }),
-    "core:test": spec("core:test", "framework_commands:_cmd_core_test", { cwd: "framework" }),
     doctor: spec("doctor", "doctor:cmd_doctor"),
     "session:start": spec("session:start", "session_start:main", {
         projectRootArg: "--project-root",
@@ -42,7 +41,6 @@ export const COMMANDS = {
     "triage:accept": spec("triage:accept", "triage_actions:main", { defaultArgs: ["accept"] }),
     "triage:status": spec("triage:status", "triage_actions:main", { defaultArgs: ["status"] }),
     "triage:scope": spec("triage:scope", "triage_scope:main"),
-    "migrate:vbrief": spec("migrate:vbrief", "framework_commands:_cmd_migrate_vbrief"),
     "cache:fetch-all": spec("cache:fetch-all", "cache:main", { defaultArgs: ["fetch-all"] }),
     "capacity:show": spec("capacity:show", "capacity_show:main", {
         projectRootArg: "--project-root",
@@ -94,7 +92,7 @@ export const COMMANDS = {
         vbriefDirArg: "--vbrief-dir",
     }),
     build: spec("build", "build_dist:main", {
-        defaultArgs: ["--version", "__DEFT_VERSION__"],
+        defaultArgs: ["--version", "__DEFT_VERSION__", "--root", "__DEFT_ROOT__"],
         cwd: "framework",
     }),
     "check:consumer": aggregate("check:consumer", [
@@ -108,8 +106,6 @@ export const COMMANDS = {
     ]),
     "check:framework-source": aggregate("check:framework-source", [
         "core:validate",
-        "core:lint",
-        "core:test",
         "toolchain:check",
         "verify:stubs",
         "verify:links",
@@ -198,49 +194,13 @@ export function cmdCoreValidate(argv) {
     process.stdout.write(`✓ All ${files.length} markdown files validated\n`);
     return 0;
 }
-function runUv(args, frameworkRoot) {
-    try {
-        execFileSync("uv", ["--project", frameworkRoot, "run", ...args], {
-            encoding: "utf8",
-            stdio: "inherit",
-        });
-        return 0;
-    }
-    catch (err) {
-        const e = err;
-        return e.status ?? 1;
-    }
-}
-export function cmdCoreLint(argv) {
-    if (argv.length > 0) {
-        process.stderr.write(`error: core:lint does not accept arguments: ${argv.join(" ")}\n`);
-        return 2;
-    }
-    const ruffCode = runUv(["ruff", "check", "."], resolveFrameworkRoot());
-    if (ruffCode !== 0)
-        return ruffCode;
-    const targets = ["run.py"];
-    if (existsSync("tests"))
-        targets.push("tests");
-    return runUv(["python", "-m", "mypy", ...targets], resolveFrameworkRoot());
+export function cmdCoreLint(_argv) {
+    process.stderr.write("error: core:lint removed (#1860); use ts:check-lane\n");
+    return 2;
 }
-export function cmdCoreTest(argv) {
-    if (argv.length > 0) {
-        process.stderr.write(`error: core:test does not accept arguments: ${argv.join(" ")}\n`);
-        return 2;
-    }
-    if (!existsSync("tests")) {
-        process.stdout.write("no tests/ (vendored consumer) -- skipping\n");
-        return 0;
-    }
-    try {
-        execFileSync("python3", ["-m", "pytest", "tests"], { encoding: "utf8", stdio: "inherit" });
-        return 0;
-    }
-    catch (err) {
-        const e = err;
-        return e.status ?? 1;
-    }
+export function cmdCoreTest(_argv) {
+    process.stderr.write("error: core:test removed (#1860); use ts:check-lane\n");
+    return 2;
 }
 function resolveVersion() {
     try {
@@ -260,7 +220,12 @@ export function resolveFrameworkRoot() {
 function argvForSpec(commandSpec, argv, projectRoot, frameworkRoot) {
     const resolved = [];
     for (const item of commandSpec.defaultArgs ?? []) {
-        resolved.push(item === "__DEFT_VERSION__" ? resolveVersion() : item);
+        if (item === "__DEFT_VERSION__")
+            resolved.push(resolveVersion());
+        else if (item === "__DEFT_ROOT__")
+            resolved.push(frameworkRoot);
+        else
+            resolved.push(item);
     }
     if (commandSpec.projectRootArg)
         resolved.push(commandSpec.projectRootArg, projectRoot);
@@ -273,44 +238,81 @@ function argvForSpec(commandSpec, argv, projectRoot, frameworkRoot) {
     resolved.push(...normalizeTaskSeparator(argv));
     return resolved;
 }
+const BUILD_DIST_RUNNER = join(dirname(fileURLToPath(import.meta.url)), "..", "release", "build-dist-runner.js");
+function runBuildDistArgv(argv) {
+    let version = null;
+    let root = null;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--version")
+            version = argv[++i];
+        else if (arg === "--root")
+            root = argv[++i];
+    }
+    if (!version || !root) {
+        process.stderr.write("build: --version and --root are required\n");
+        return 2;
+    }
+    const result = spawnSync(process.execPath, [BUILD_DIST_RUNNER, version, root], {
+        cwd: root,
+        encoding: "utf8",
+        env: { ...process.env, DEFT_RELEASE_VERSION: version },
+    });
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    return result.status ?? 1;
+}
 const TS_INLINE = {
     "framework_commands:_cmd_core_validate": (argv) => cmdCoreValidate(argv),
-    "framework_commands:_cmd_core_lint": (argv) => cmdCoreLint(argv),
-    "framework_commands:_cmd_core_test": (argv) => cmdCoreTest(argv),
     "doctor:cmd_doctor": (argv) => cmdDoctor(argv),
+    "build_dist:main": (argv) => runBuildDistArgv(argv),
 };
-function spawnPythonEntrypoint(entrypoint, argv, cwd, frameworkRoot, noArgv) {
-    const scriptsDir = join(frameworkRoot, "scripts").replace(/\\/g, "/");
-    const code = [
-        "import sys, importlib, importlib.util, inspect, os",
-        `sys.path.insert(0, ${JSON.stringify(scriptsDir)})`,
-        `os.chdir(${JSON.stringify(cwd.replace(/\\/g, "/"))})`,
-        `entrypoint = ${JSON.stringify(entrypoint)}`,
-        "module_ref, _, func_name = entrypoint.partition(':')",
-        "if module_ref.endswith('.py'):",
-        "    path = __import__('pathlib').Path(module_ref)",
-        "    if not path.is_absolute():",
-        `        path = __import__('pathlib').Path(${JSON.stringify(scriptsDir)}) / module_ref`,
-        "    module_name = '_deft_cmd_' + path.stem.replace('-', '_')",
-        "    spec = importlib.util.spec_from_file_location(module_name, path)",
-        "    mod = importlib.util.module_from_spec(spec)",
-        "    spec.loader.exec_module(mod)",
-        "else:",
-        "    mod = importlib.import_module(module_ref)",
-        "func = getattr(mod, func_name)",
-        `argv = ${JSON.stringify(argv)}`,
-        "if not callable(func):",
-        "    raise TypeError('not callable')",
-        noArgv
-            ? "code = func() if len(inspect.signature(func).parameters) == 0 else func([])"
-            : "code = func() if len(inspect.signature(func).parameters) == 0 else func(argv)",
-        "sys.exit(int(code or 0))",
-    ].join("\n");
+const ENTRYPOINT_VERB = {
+    "session_start:main": "session-start",
+    "triage_welcome:main": "triage-welcome",
+    "triage_bootstrap:main": "triage-bootstrap",
+    "triage_summary:main": "triage-summary",
+    "triage_queue:main": "triage-queue",
+    "triage_actions:main": "triage-actions",
+    "triage_scope:main": "triage-scope",
+    "cache:main": "cache",
+    "capacity_show:main": "capacity-show",
+    "scope_demote:main": "scope-demote",
+    "toolchain-check.py:main": "toolchain-check",
+    "verify-stubs.py:main": "verify-stubs",
+    "validate-links.py:main": "validate-links",
+    "rule_ownership_lint:main": "rule-ownership-lint",
+    "preflight_branch:main": "verify-branch",
+    "verify_encoding:main": "verify-encoding",
+    "verify_vbrief_conformance:main": "vbrief-validate",
+    "preflight_gh:main": "preflight-gh",
+    "verify_scm_boundary:main": "verify-scm-boundary",
+    "verify_no_task_runtime:main": "verify-no-task-runtime",
+    "preflight_cache:main": "preflight-cache",
+    "preflight_wip_cap:main": "verify-wip-cap",
+    "pack_render:main": "pack-render",
+    "validate_strategy_output:main": "validate-strategy-output",
+    "vbrief_validate:main": "vbrief-validate",
+};
+function deftCliBin(frameworkRoot) {
+    return join(frameworkRoot, "packages", "cli", "dist", "bin.js");
+}
+function spawnDeftVerb(verb, argv, cwd, frameworkRoot) {
+    const bin = deftCliBin(frameworkRoot);
+    if (!existsSync(bin)) {
+        return {
+            code: 2,
+            stdout: "",
+            stderr: `deft CLI not built at ${bin}; run pnpm run build first\n`,
+        };
+    }
     try {
-        const stdout = execFileSync("uv", ["--project", frameworkRoot, "run", "python", "-c", code], {
-            cwd: frameworkRoot,
+        const stdout = execFileSync(process.execPath, [bin, verb, ...argv], {
+            cwd,
             encoding: "utf8",
-            env: { ...process.env, PYTHONUTF8: "1", DEFT_CACHE_DISABLE: "1" },
+            env: { ...process.env, DEFT_CACHE_DISABLE: "1" },
         });
         return { code: 0, stdout: typeof stdout === "string" ? stdout : "", stderr: "" };
     }
@@ -350,7 +352,23 @@ function invokeEntrypoint(entrypoint, argv, cwd, frameworkRoot, noArgv, capture)
         }
         return { code: inline(argv), stdout: "", stderr: "" };
     }
-    return spawnPythonEntrypoint(entrypoint, argv, cwd, frameworkRoot, noArgv);
+    const verb = ENTRYPOINT_VERB[entrypoint];
+    if (verb) {
+        const effectiveArgv = noArgv ? [] : argv;
+        const result = spawnDeftVerb(verb, effectiveArgv, cwd, frameworkRoot);
+        if (capture)
+            return result;
+        if (result.stdout)
+            process.stdout.write(result.stdout);
+        if (result.stderr)
+            process.stderr.write(result.stderr);
+        return result;
+    }
+    return {
+        code: 2,
+        stdout: "",
+        stderr: `unknown entrypoint (Python scripts removed #1860): ${entrypoint}\n`,
+    };
 }
 export function runFrameworkCommand(name, argv = [], options = {}) {
     const root = resolve(options.projectRoot ?? process.cwd());

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

@@ -0,0 +1,87 @@
+/** Matches `## Current shape (as of pass-N)` — same pattern as vbrief-reconcile/umbrellas.ts. */
+export declare const CURRENT_SHAPE_HEADER_RE: RegExp;
+export declare const SECTION_MARKERS: {
+    readonly lastUpdated: RegExp;
+    readonly lastPassType: RegExp;
+    readonly childCount: RegExp;
+    readonly childCountHistory: RegExp;
+    readonly openChildren: RegExp;
+    readonly closedChildren: RegExp;
+    readonly waveOrder: RegExp;
+    readonly openQuestions: RegExp;
+    readonly readingOrder: RegExp;
+};
+export type SectionKey = keyof typeof SECTION_MARKERS;
+/** Required per AGENTS.md #1152; openQuestions is optional. */
+export declare const REQUIRED_SECTIONS: readonly SectionKey[];
+export declare const OPTIONAL_SECTIONS: readonly SectionKey[];
+export interface IssueComment {
+    readonly id: number;
+    readonly body: string;
+    readonly htmlUrl: string;
+    readonly updatedAt: string;
+}
+export interface CurrentShapeComment extends IssueComment {
+    readonly pass: number;
+}
+export interface SectionPresence {
+    readonly present: SectionKey[];
+    readonly missing: SectionKey[];
+    readonly optionalPresent: SectionKey[];
+    readonly optionalMissing: SectionKey[];
+}
+export interface CurrentShapeResult {
+    readonly issueNumber: number;
+    readonly repo: string;
+    readonly commentId: number;
+    readonly htmlUrl: string;
+    readonly pass: number;
+    readonly body: string;
+    readonly sections: SectionPresence;
+}
+export type ScmFetcher = (repo: string, issueNumber: number) => IssueComment[] | {
+    error: string;
+};
+export interface RunCurrentShapeOptions {
+    readonly issueNumber: number;
+    readonly projectRoot: string;
+    readonly repo?: string | null;
+    readonly jsonMode?: boolean;
+    readonly strict?: boolean;
+    readonly fetchComments?: ScmFetcher;
+    readonly writeOut?: (text: string) => void;
+    readonly writeErr?: (text: string) => void;
+}
+/** Merge `gh api --paginate` concatenated JSON array pages into comment rows. */
+export declare function parseCommentsFromGhStdout(stdout: string): IssueComment[];
+export declare function extractPassFromBody(body: string): number | null;
+/** Pick the canonical comment — highest pass-N; tie-break by comment id (latest). */
+export declare function selectCurrentShapeComment(comments: readonly IssueComment[]): CurrentShapeComment | null;
+export declare function detectSections(body: string): SectionPresence;
+export declare function sectionsRecord(presence: SectionPresence): Record<string, boolean>;
+export declare const NO_CURRENT_SHAPE_MESSAGE: string;
+export declare function fetchCurrentShape(options: {
+    repo: string;
+    issueNumber: number;
+    fetchComments?: ScmFetcher;
+}): {
+    ok: true;
+    result: CurrentShapeResult;
+} | {
+    ok: false;
+    error: string;
+    kind: "not-found" | "config";
+};
+export declare function emitCurrentShape(result: CurrentShapeResult, options: {
+    jsonMode: boolean;
+    writeOut: (text: string) => void;
+}): number;
+export declare function runCurrentShape(options: RunCurrentShapeOptions): number;
+export declare function parseCurrentShapeArgv(argv: readonly string[]): {
+    issueNumber: number | null;
+    repo: string | null;
+    jsonMode: boolean;
+    strict: boolean;
+    passthroughError?: string;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/umbrella-current-shape/index.js

@@ -0,0 +1,329 @@
+import { spawnSync } from "node:child_process";
+import { resolveBinary } from "../scm/binary.js";
+import { SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
+import { resolveRepo } from "../triage/queue/repo.js";
+/** Matches `## Current shape (as of pass-N)` — same pattern as vbrief-reconcile/umbrellas.ts. */
+export const CURRENT_SHAPE_HEADER_RE = /^## Current shape \(as of pass-(\d+)\)/m;
+export const SECTION_MARKERS = {
+    lastUpdated: /^Last updated:\s/m,
+    lastPassType: /^Last pass type:\s/m,
+    childCount: /^Child count:\s/m,
+    childCountHistory: /^Child-count history:\s/m,
+    openChildren: /^### Open children\s*$/m,
+    closedChildren: /^### Closed children\s*$/m,
+    waveOrder: /^### Wave order\s*$/m,
+    openQuestions: /^### Open questions\s*$/m,
+    readingOrder: /^### Reading order for fresh contributors\s*$/m,
+};
+/** Required per AGENTS.md #1152; openQuestions is optional. */
+export const REQUIRED_SECTIONS = [
+    "lastUpdated",
+    "lastPassType",
+    "childCount",
+    "childCountHistory",
+    "openChildren",
+    "closedChildren",
+    "waveOrder",
+    "readingOrder",
+];
+export const OPTIONAL_SECTIONS = ["openQuestions"];
+function mapCommentEntry(entry) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+        return null;
+    }
+    const rec = entry;
+    if (typeof rec.id !== "number" || typeof rec.body !== "string") {
+        return null;
+    }
+    return {
+        id: rec.id,
+        body: rec.body,
+        htmlUrl: typeof rec.html_url === "string" ? rec.html_url : "",
+        updatedAt: typeof rec.updated_at === "string" ? rec.updated_at : "",
+    };
+}
+/** Merge `gh api --paginate` concatenated JSON array pages into comment rows. */
+export function parseCommentsFromGhStdout(stdout) {
+    const comments = [];
+    const text = stdout.trim();
+    if (!text) {
+        return comments;
+    }
+    const pages = [];
+    try {
+        pages.push(JSON.parse(text));
+    }
+    catch {
+        let idx = 0;
+        while (idx < text.length) {
+            while (idx < text.length && /\s/.test(text[idx] ?? "")) {
+                idx += 1;
+            }
+            if (idx >= text.length) {
+                break;
+            }
+            const slice = text.slice(idx);
+            if (!slice.startsWith("[")) {
+                break;
+            }
+            let depth = 0;
+            let end = -1;
+            for (let j = 0; j < slice.length; j += 1) {
+                const ch = slice[j];
+                if (ch === "[") {
+                    depth += 1;
+                }
+                else if (ch === "]") {
+                    depth -= 1;
+                    if (depth === 0) {
+                        end = j + 1;
+                        break;
+                    }
+                }
+            }
+            if (end < 0) {
+                throw new SyntaxError("invalid paginated JSON");
+            }
+            pages.push(JSON.parse(slice.slice(0, end)));
+            idx += end;
+        }
+    }
+    for (const page of pages) {
+        if (!Array.isArray(page)) {
+            continue;
+        }
+        for (const entry of page) {
+            const mapped = mapCommentEntry(entry);
+            if (mapped !== null) {
+                comments.push(mapped);
+            }
+        }
+    }
+    return comments;
+}
+function defaultFetchComments(repo, issueNumber) {
+    const binary = resolveBinary();
+    const path = `repos/${repo}/issues/${issueNumber}/comments?per_page=100`;
+    const proc = spawnSync(binary, ["api", "--paginate", path], {
+        encoding: "utf8",
+        maxBuffer: SUBPROCESS_MAX_BUFFER,
+    });
+    if (proc.error !== undefined) {
+        return {
+            error: `fetch comments #${issueNumber} (${repo}) failed: ${proc.error.message}`,
+        };
+    }
+    if (proc.status !== 0) {
+        return {
+            error: `fetch comments #${issueNumber} (${repo}) failed: ${(proc.stderr || proc.stdout || "").trim()}`,
+        };
+    }
+    try {
+        return parseCommentsFromGhStdout(String(proc.stdout ?? ""));
+    }
+    catch (exc) {
+        return {
+            error: `fetch comments #${issueNumber} (${repo}) returned non-JSON: ${String(exc)}`,
+        };
+    }
+}
+export function extractPassFromBody(body) {
+    const match = CURRENT_SHAPE_HEADER_RE.exec(body);
+    if (!match?.[1]) {
+        return null;
+    }
+    const pass = Number(match[1]);
+    return Number.isFinite(pass) ? pass : null;
+}
+/** Pick the canonical comment — highest pass-N; tie-break by comment id (latest). */
+export function selectCurrentShapeComment(comments) {
+    let best = null;
+    for (const comment of comments) {
+        const pass = extractPassFromBody(comment.body);
+        if (pass === null) {
+            continue;
+        }
+        const candidate = { ...comment, pass };
+        if (best === null ||
+            candidate.pass > best.pass ||
+            (candidate.pass === best.pass && candidate.id > best.id)) {
+            best = candidate;
+        }
+    }
+    return best;
+}
+export function detectSections(body) {
+    const present = [];
+    const missing = [];
+    const optionalPresent = [];
+    const optionalMissing = [];
+    for (const key of REQUIRED_SECTIONS) {
+        if (SECTION_MARKERS[key].test(body)) {
+            present.push(key);
+        }
+        else {
+            missing.push(key);
+        }
+    }
+    for (const key of OPTIONAL_SECTIONS) {
+        if (SECTION_MARKERS[key].test(body)) {
+            optionalPresent.push(key);
+        }
+        else {
+            optionalMissing.push(key);
+        }
+    }
+    return { present, missing, optionalPresent, optionalMissing };
+}
+export function sectionsRecord(presence) {
+    const out = {};
+    for (const key of REQUIRED_SECTIONS) {
+        out[key] = presence.present.includes(key);
+    }
+    for (const key of OPTIONAL_SECTIONS) {
+        out[key] = presence.optionalPresent.includes(key);
+    }
+    return out;
+}
+export const NO_CURRENT_SHAPE_MESSAGE = "No ## Current shape (as of pass-N) comment found on this issue. " +
+    "Create one per AGENTS.md ## Umbrella current-shape convention (#1152) — " +
+    "do not fall back to the issue body (stale by design).";
+export function fetchCurrentShape(options) {
+    const fetcher = options.fetchComments ?? defaultFetchComments;
+    const fetched = fetcher(options.repo, options.issueNumber);
+    if (!Array.isArray(fetched)) {
+        return { ok: false, error: fetched.error, kind: "config" };
+    }
+    const selected = selectCurrentShapeComment(fetched);
+    if (selected === null) {
+        return { ok: false, error: NO_CURRENT_SHAPE_MESSAGE, kind: "not-found" };
+    }
+    const sections = detectSections(selected.body);
+    return {
+        ok: true,
+        result: {
+            issueNumber: options.issueNumber,
+            repo: options.repo,
+            commentId: selected.id,
+            htmlUrl: selected.htmlUrl,
+            pass: selected.pass,
+            body: selected.body,
+            sections,
+        },
+    };
+}
+export function emitCurrentShape(result, options) {
+    if (options.jsonMode) {
+        const payload = {
+            issueNumber: result.issueNumber,
+            repo: result.repo,
+            commentId: result.commentId,
+            htmlUrl: result.htmlUrl,
+            pass: result.pass,
+            body: result.body,
+            sections: sectionsRecord(result.sections),
+            missingSections: result.sections.missing,
+            missingOptionalSections: result.sections.optionalMissing,
+        };
+        options.writeOut(`${JSON.stringify(payload)}\n`);
+    }
+    else {
+        options.writeOut(`${result.body}\n`);
+    }
+    return 0;
+}
+export function runCurrentShape(options) {
+    const writeOut = options.writeOut ?? ((text) => process.stdout.write(text));
+    const writeErr = options.writeErr ?? ((text) => process.stderr.write(text));
+    if (!Number.isInteger(options.issueNumber) || options.issueNumber <= 0) {
+        writeErr("umbrella:current-shape: issue number must be a positive integer\n");
+        return 2;
+    }
+    const repo = resolveRepo(options.repo ?? null, options.projectRoot);
+    if (repo === null) {
+        writeErr("umbrella:current-shape: could not resolve owner/repo — pass --repo OWNER/REPO or run inside a git repo with origin\n");
+        return 2;
+    }
+    const fetched = fetchCurrentShape({
+        repo,
+        issueNumber: options.issueNumber,
+        fetchComments: options.fetchComments,
+    });
+    if (!fetched.ok) {
+        writeErr(`umbrella:current-shape: ${fetched.error}\n`);
+        return fetched.kind === "config" ? 2 : 1;
+    }
+    if (options.strict === true && fetched.result.sections.missing.length > 0) {
+        writeErr(`umbrella:current-shape: --strict: missing required section(s): ${fetched.result.sections.missing.join(", ")}\n`);
+        return 1;
+    }
+    return emitCurrentShape(fetched.result, {
+        jsonMode: options.jsonMode ?? false,
+        writeOut,
+    });
+}
+export function parseCurrentShapeArgv(argv) {
+    let issueNumber = null;
+    let repo = null;
+    let jsonMode = false;
+    let strict = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i] ?? "";
+        if (arg === "--json") {
+            jsonMode = true;
+        }
+        else if (arg === "--strict") {
+            strict = true;
+        }
+        else if (arg === "--repo") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    issueNumber,
+                    repo,
+                    jsonMode,
+                    strict,
+                    passthroughError: "argument --repo: expected one argument",
+                };
+            }
+            repo = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--repo=")) {
+            repo = arg.slice("--repo=".length);
+        }
+        else if (arg.startsWith("-")) {
+            return {
+                issueNumber,
+                repo,
+                jsonMode,
+                strict,
+                passthroughError: `unknown flag: ${arg}`,
+            };
+        }
+        else if (issueNumber === null) {
+            const parsed = Number(arg);
+            if (!Number.isInteger(parsed) || parsed <= 0) {
+                return {
+                    issueNumber,
+                    repo,
+                    jsonMode,
+                    strict,
+                    passthroughError: `invalid issue number: ${arg}`,
+                };
+            }
+            issueNumber = parsed;
+        }
+        else {
+            return {
+                issueNumber,
+                repo,
+                jsonMode,
+                strict,
+                passthroughError: `unexpected positional argument: ${arg}`,
+            };
+        }
+    }
+    return { issueNumber, repo, jsonMode, strict };
+}
+//# sourceMappingURL=index.js.map

package/dist/vbrief-validate/precutover.d.ts

@@ -16,6 +16,9 @@ export interface PrecutoverDetection {
     reasons: string[];
 }
 export declare function detectPreCutover(projectRoot: string): PrecutoverDetection;
+/** Last release that ships `scripts/migrate_vbrief.py` on the consumer deposit path (#2068). */
+export declare const FROZEN_PRECUTOVER_MIGRATION_TAG = "v0.59.0";
+export declare function frozenPreCutoverMigrationGuidance(): string;
 export declare function renderPrecutoverLine(projectRoot: string): string;
 export { isFullSpecState, isGreenfieldSpecExport };
 //# sourceMappingURL=precutover.d.ts.map