@deftai/directive 0.106.0 → 0.108.0

package/dist/occupancy-steal.d.ts

@@ -3,6 +3,7 @@ export declare function parseArgs(argv: readonly string[]): {
     projectRoot: string;
     confirm: boolean;
     occupant: string | null;
+    sessionId?: string;
     error?: string;
 };
 export declare function run(argv: readonly string[]): number;

package/dist/occupancy-steal.js

@@ -10,25 +10,52 @@ export function parseArgs(argv) {
         }
         else if (arg === "--occupant") {
             const value = argv[i + 1];
-            if (value === undefined) {
+            if (value === undefined || value.startsWith("--")) {
                 return { ...parsed, error: "argument --occupant: expected one argument" };
             }
             parsed.occupant = value;
             i += 1;
         }
         else if (arg?.startsWith("--occupant=")) {
-            parsed.occupant = arg.slice("--occupant=".length);
+            const value = arg.slice("--occupant=".length);
+            if (value.length === 0 || value.startsWith("--")) {
+                return { ...parsed, error: "argument --occupant: expected one argument" };
+            }
+            parsed.occupant = value;
         }
         else if (arg === "--project-root") {
             const value = argv[i + 1];
-            if (value === undefined) {
+            if (value === undefined || value.startsWith("--")) {
                 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);
+            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 if (arg === "--session-id") {
+            const value = argv[i + 1];
+            if (value === undefined || value.startsWith("--")) {
+                return { ...parsed, error: "argument --session-id: expected one argument" };
+            }
+            const sessionId = value.trim();
+            if (sessionId.length === 0 || sessionId.startsWith("--")) {
+                return { ...parsed, error: "argument --session-id: expected a non-empty value" };
+            }
+            parsed.sessionId = sessionId;
+            i += 1;
+        }
+        else if (arg?.startsWith("--session-id=")) {
+            const sessionId = arg.slice("--session-id=".length).trim();
+            if (sessionId.length === 0 || sessionId.startsWith("--")) {
+                return { ...parsed, error: "argument --session-id: expected a non-empty value" };
+            }
+            parsed.sessionId = sessionId;
         }
         else {
             return { ...parsed, error: `unrecognized argument: ${arg}` };
@@ -43,6 +70,7 @@ export function run(argv) {
         return 2;
     }
     const result = stealOccupancy(resolve(args.projectRoot), {
+        sessionId: args.sessionId,
         confirm: args.confirm,
         occupant: args.occupant ?? undefined,
         env: process.env,

package/dist/render-cli/prd-render-cli.js

@@ -1,13 +1,11 @@
 /**
  * Thin CLI wrapper for prd-render (mirrors ``scripts/prd_render.py``).
  *
- * Supports `--project-root <dir>` to resolve the spec artifact via the layout
- * resolver (#2132), preferring `xbrief/specification.xbrief.json` on migrated
- * trees and falling back to `vbrief/specification.vbrief.json` on legacy trees.
+ * Supports `--project-root <dir>` to resolve full-spec or greenfield authority
+ * through the shared authority resolver (#2132 / #3598).
  * When `--spec` is explicitly provided it takes precedence over `--project-root`.
  * Direct `--spec` / `--output` / `--force` flags are still accepted unchanged.
  */
-import { layout } from "@deftai/directive-core";
 import { parsePrdArgv, prdRenderMain } from "@deftai/directive-core/render";
 function parsePrdRenderCliArgv(argv) {
     const remaining = [];
@@ -30,12 +28,10 @@ function parsePrdRenderCliArgv(argv) {
 export function runPrdRenderCli(argv) {
     const { projectRoot, remaining } = parsePrdRenderCliArgv(argv);
     const parsedArgs = parsePrdArgv(remaining);
-    const spec = parsedArgs.spec !== undefined
-        ? parsedArgs.spec
-        : projectRoot !== undefined
-            ? layout.resolveSpecArtifactPath(projectRoot)
-            : undefined;
-    prdRenderMain({ ...parsedArgs, spec });
+    prdRenderMain({
+        ...parsedArgs,
+        projectRoot: parsedArgs.spec === undefined ? projectRoot : undefined,
+    });
     return 0;
 }
 //# sourceMappingURL=prd-render-cli.js.map

package/dist/session-ready.d.ts

@@ -4,6 +4,8 @@ export interface ParsedSessionReadyArgs {
     emitJson: boolean;
     withNetwork: boolean;
     repo: string | null;
+    /** #3611: explicit lifecycle owner injected by a host hook bridge. */
+    sessionId: string | null;
     error?: string;
 }
 /** Parse session:ready CLI args. */

package/dist/session-ready.js

@@ -15,6 +15,7 @@ export function parseArgs(argv) {
         emitJson: false,
         withNetwork: false,
         repo: null,
+        sessionId: null,
     };
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -33,13 +34,13 @@ export function parseArgs(argv) {
         if (arg === "--help" || arg === "-h") {
             return {
                 ...parsed,
-                error: "usage: session:ready [--project-root <path>] [--repo OWNER/NAME] [--with-network] [--json]\n" +
+                error: "usage: session:ready [--project-root <path>] [--repo OWNER/NAME] [--session-id <id>] [--with-network] [--json]\n" +
                     "  One-shot recovery: session:start (if needed) + gated ritual + cache recovery (#2993).",
             };
         }
         if (arg === "--project-root") {
             const value = argv[i + 1];
-            if (value === undefined) {
+            if (value === undefined || value.startsWith("--")) {
                 return { ...parsed, error: "argument --project-root: expected one argument" };
             }
             parsed.projectRoot = value;
@@ -47,12 +48,37 @@ export function parseArgs(argv) {
             continue;
         }
         if (arg.startsWith("--project-root=")) {
-            parsed.projectRoot = arg.slice("--project-root=".length);
+            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;
+            continue;
+        }
+        if (arg === "--session-id") {
+            const value = argv[i + 1];
+            if (value === undefined || value.startsWith("--")) {
+                return { ...parsed, error: "argument --session-id: expected one argument" };
+            }
+            const sessionId = value.trim();
+            if (sessionId.length === 0 || sessionId.startsWith("--")) {
+                return { ...parsed, error: "argument --session-id: expected a non-empty value" };
+            }
+            parsed.sessionId = sessionId;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--session-id=")) {
+            const sessionId = arg.slice("--session-id=".length).trim();
+            if (sessionId.length === 0 || sessionId.startsWith("--")) {
+                return { ...parsed, error: "argument --session-id: expected a non-empty value" };
+            }
+            parsed.sessionId = sessionId;
             continue;
         }
         if (arg === "--repo") {
             const value = argv[i + 1];
-            if (value === undefined) {
+            if (value === undefined || value.startsWith("--")) {
                 return { ...parsed, error: "argument --repo: expected one argument" };
             }
             parsed.repo = value;
@@ -60,7 +86,11 @@ export function parseArgs(argv) {
             continue;
         }
         if (arg.startsWith("--repo=")) {
-            parsed.repo = arg.slice("--repo=".length);
+            const value = arg.slice("--repo=".length);
+            if (value.length === 0 || value.startsWith("--")) {
+                return { ...parsed, error: "argument --repo: expected one argument" };
+            }
+            parsed.repo = value;
             continue;
         }
         if (arg.startsWith("-")) {
@@ -80,6 +110,7 @@ export function run(argv = process.argv.slice(2)) {
     const projectRoot = resolve(args.projectRoot);
     const result = runSessionReady(projectRoot, {
         repo: args.repo,
+        sessionId: args.sessionId ?? undefined,
         sessionStartOptions: {
             allowOptionalNetwork: args.withNetwork ? true : undefined,
             writeHistory: false,
@@ -89,6 +120,7 @@ export function run(argv = process.argv.slice(2)) {
         process.stdout.write(`${JSON.stringify({
             ready: result.code === 0,
             exit_code: result.code,
+            session_id: result.sessionId,
             path: result.path,
             message: result.message,
             steps: result.steps,

package/dist/session-start.d.ts

@@ -36,6 +36,8 @@ export interface ParsedSessionStartArgs {
     steal: boolean;
     confirm: boolean;
     occupant: string | null;
+    /** #3611: explicit lifecycle owner injected by a host hook bridge. */
+    sessionId: string | null;
     error?: string;
 }
 /** Parse session:start CLI args, mirroring scripts/session_start.py. */

package/dist/session-start.js

@@ -34,6 +34,7 @@ export function parseArgs(argv) {
         steal: false,
         confirm: false,
         occupant: null,
+        sessionId: null,
     };
     const dialInputs = {};
     for (let i = 0; i < argv.length; i += 1) {
@@ -82,25 +83,33 @@ export function parseArgs(argv) {
         }
         else if (arg === "--project-root") {
             const value = argv[i + 1];
-            if (value === undefined) {
+            if (value === undefined || value.startsWith("--")) {
                 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);
+            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 if (arg === "--defer") {
             const value = argv[i + 1];
-            if (value === undefined) {
+            if (value === undefined || value.startsWith("--")) {
                 return { ...parsed, error: "argument --defer: expected one argument" };
             }
             parsed.deferValues.push(value);
             i += 1;
         }
         else if (arg?.startsWith("--defer=")) {
-            parsed.deferValues.push(arg.slice("--defer=".length));
+            const value = arg.slice("--defer=".length);
+            if (value.length === 0 || value.startsWith("--")) {
+                return { ...parsed, error: "argument --defer: expected one argument" };
+            }
+            parsed.deferValues.push(value);
         }
         else if (arg === "--task-size" || arg === "--ceremony-task-size") {
             const value = argv[i + 1];
@@ -282,16 +291,39 @@ export function parseArgs(argv) {
         else if (arg === "--confirm") {
             parsed.confirm = true;
         }
+        else if (arg === "--session-id") {
+            const value = argv[i + 1];
+            if (value === undefined || value.startsWith("--")) {
+                return { ...parsed, error: "argument --session-id: expected one argument" };
+            }
+            const sessionId = value.trim();
+            if (sessionId.length === 0 || sessionId.startsWith("--")) {
+                return { ...parsed, error: "argument --session-id: expected a non-empty value" };
+            }
+            parsed.sessionId = sessionId;
+            i += 1;
+        }
+        else if (arg?.startsWith("--session-id=")) {
+            const sessionId = arg.slice("--session-id=".length).trim();
+            if (sessionId.length === 0 || sessionId.startsWith("--")) {
+                return { ...parsed, error: "argument --session-id: expected a non-empty value" };
+            }
+            parsed.sessionId = sessionId;
+        }
         else if (arg === "--occupant") {
             const value = argv[i + 1];
-            if (value === undefined) {
+            if (value === undefined || value.startsWith("--")) {
                 return { ...parsed, error: "argument --occupant: expected one argument" };
             }
             parsed.occupant = value;
             i += 1;
         }
         else if (arg?.startsWith("--occupant=")) {
-            parsed.occupant = arg.slice("--occupant=".length);
+            const value = arg.slice("--occupant=".length);
+            if (value.length === 0 || value.startsWith("--")) {
+                return { ...parsed, error: "argument --occupant: expected one argument" };
+            }
+            parsed.occupant = value;
         }
         else {
             return { ...parsed, error: `unrecognized argument: ${arg}` };
@@ -358,6 +390,7 @@ export function run(argv) {
             steal: args.steal ? true : undefined,
             confirm: args.confirm ? true : undefined,
             occupant: args.occupant ?? undefined,
+            sessionId: args.sessionId ?? undefined,
             ...(args.ceremonyDepthOverride !== null
                 ? {
                     ceremonyDial: selectCeremonyDepth({

package/dist/toolchain-check.d.ts

@@ -2,6 +2,7 @@
 import { type CommandRunner } from "@deftai/directive-core/verify-env";
 export interface ToolchainCheckRunOptions {
     readonly runner?: CommandRunner;
+    readonly env?: NodeJS.ProcessEnv;
 }
 export declare function run(argv?: readonly string[], options?: ToolchainCheckRunOptions): number;
 //# sourceMappingURL=toolchain-check.d.ts.map

package/dist/toolchain-check.js

@@ -1,9 +1,48 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
 import { runToolchainCheck } from "@deftai/directive-core/verify-env";
+function parseArgs(argv) {
+    let consumer = false;
+    let projectRoot = process.cwd();
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index] ?? "";
+        if (arg === "--consumer") {
+            consumer = true;
+            continue;
+        }
+        if (arg === "--project-root") {
+            const value = argv[index + 1];
+            if (value === undefined || value.trim() === "" || value.startsWith("-")) {
+                return { consumer, projectRoot, error: "--project-root requires a path" };
+            }
+            projectRoot = value;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--project-root=")) {
+            const value = arg.slice("--project-root=".length);
+            if (value.trim() === "") {
+                return { consumer, projectRoot, error: "--project-root requires a path" };
+            }
+            projectRoot = value;
+            continue;
+        }
+        return { consumer, projectRoot, error: `unrecognized argument: ${arg}` };
+    }
+    return { consumer, projectRoot };
+}
 export function run(argv = process.argv.slice(2), options = {}) {
-    const consumer = argv.includes("--consumer");
-    const result = runToolchainCheck(options.runner, { consumer });
+    const parsed = parseArgs(argv);
+    if (parsed.error !== undefined) {
+        process.stderr.write(`toolchain-check: ${parsed.error}\n`);
+        process.stderr.write("Usage: deft toolchain-check [--consumer] [--project-root <path>]\n");
+        return 2;
+    }
+    const result = runToolchainCheck(options.runner, {
+        consumer: parsed.consumer,
+        projectRoot: parsed.projectRoot,
+        env: options.env ?? process.env,
+    });
     for (const line of result.lines) {
         process.stdout.write(`${line}\n`);
     }

package/dist/triage-actions.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { accept, createDefaultDeps, deferAction, formatDecision, history, markDuplicate, needsAc, reject, reset, status, TriageError, UpstreamCloseError, } from "@deftai/directive-core/dist/triage/actions/index.js";
+import { accept, createDefaultDeps, deferAction, formatAcceptOutput, formatDecision, history, markDuplicate, needsAc, reject, reset, status, TriageError, UpstreamCloseError, } from "@deftai/directive-core/dist/triage/actions/index.js";
 const VALID_CMDS = new Set([
     "accept",
     "reject",
@@ -158,8 +158,7 @@ export function run(argv) {
                 autoPromote: args.autoPromote === true,
                 force: args.force === true,
             });
-            const promoteNote = args.autoPromote === true ? " + auto-promote" : "";
-            process.stdout.write(`accept #${n} (${repo}) -> ${decisionId}${promoteNote}\n`);
+            process.stdout.write(`${formatAcceptOutput(n, repo, decisionId, { autoPromote: args.autoPromote === true })}\n`);
         }
         else if (args.cmd === "reject") {
             const decisionId = reject(n, repo, args.reason ?? "", deps, {

package/dist/triage-evaluate.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+interface Parsed {
+    projectRoot: string;
+    repo: string | null;
+    issues: number[];
+    concurrency: number;
+    json: boolean;
+    error?: string;
+}
+export declare function parseArgs(argv: string[]): Parsed;
+export declare function run(argv: string[]): Promise<number>;
+export declare function main(argv: string[]): Promise<number>;
+export {};
+//# sourceMappingURL=triage-evaluate.d.ts.map

package/dist/triage-evaluate.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { DEFAULT_CONCURRENCY, EvaluateError, evaluateIssues, renderEvaluateText, } from "@deftai/directive-core/dist/triage/evaluate/index.js";
+import { interceptHelp } from "@deftai/directive-core/dist/triage/help/index.js";
+import { resolveRepo } from "@deftai/directive-core/dist/triage/queue/repo.js";
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: process.env.DEFT_PROJECT_ROOT ?? process.cwd(),
+        repo: process.env.DEFT_TRIAGE_REPO ?? null,
+        issues: [],
+        concurrency: DEFAULT_CONCURRENCY,
+        json: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined || arg === "--") {
+            continue;
+        }
+        if (arg === "--project-root") {
+            if (i + 1 >= argv.length) {
+                return { ...parsed, error: "--project-root requires a path" };
+            }
+            i += 1;
+            const value = argv[i];
+            if (value === undefined) {
+                return { ...parsed, error: "--project-root requires a path" };
+            }
+            parsed.projectRoot = value;
+        }
+        else if (arg.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--repo") {
+            if (i + 1 >= argv.length) {
+                return { ...parsed, error: "--repo requires owner/name" };
+            }
+            i += 1;
+            const value = argv[i];
+            if (value === undefined) {
+                return { ...parsed, error: "--repo requires owner/name" };
+            }
+            parsed.repo = value;
+        }
+        else if (arg.startsWith("--repo=")) {
+            parsed.repo = arg.slice("--repo=".length);
+        }
+        else if (arg === "--issue") {
+            if (i + 1 >= argv.length) {
+                return { ...parsed, error: "--issue requires a number" };
+            }
+            i += 1;
+            const value = argv[i];
+            if (value === undefined) {
+                return { ...parsed, error: "--issue requires a number" };
+            }
+            const n = Number.parseInt(value, 10);
+            if (!Number.isInteger(n) || n < 1) {
+                return { ...parsed, error: `--issue invalid: ${value}` };
+            }
+            parsed.issues.push(n);
+        }
+        else if (arg.startsWith("--issue=")) {
+            const n = Number.parseInt(arg.slice("--issue=".length), 10);
+            if (!Number.isInteger(n) || n < 1) {
+                return { ...parsed, error: `--issue invalid: ${arg}` };
+            }
+            parsed.issues.push(n);
+        }
+        else if (arg === "--concurrency") {
+            if (i + 1 >= argv.length) {
+                return { ...parsed, error: "--concurrency requires a positive integer" };
+            }
+            i += 1;
+            const value = argv[i];
+            if (value === undefined) {
+                return { ...parsed, error: "--concurrency requires a positive integer" };
+            }
+            const n = Number.parseInt(value, 10);
+            if (!Number.isInteger(n) || n < 1) {
+                return { ...parsed, error: `--concurrency invalid: ${value}` };
+            }
+            parsed.concurrency = n;
+        }
+        else if (arg.startsWith("--concurrency=")) {
+            const n = Number.parseInt(arg.slice("--concurrency=".length), 10);
+            if (!Number.isInteger(n) || n < 1) {
+                return { ...parsed, error: `--concurrency invalid: ${arg}` };
+            }
+            parsed.concurrency = n;
+        }
+        else if (arg === "--json") {
+            parsed.json = true;
+        }
+        else if (arg.startsWith("-")) {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+        else {
+            const n = Number.parseInt(arg.replace(/^#/u, ""), 10);
+            if (!Number.isInteger(n) || n < 1) {
+                return { ...parsed, error: `invalid issue number: ${arg}` };
+            }
+            parsed.issues.push(n);
+        }
+    }
+    return parsed;
+}
+export async function run(argv) {
+    const help = interceptHelp("triage_evaluate", argv);
+    if (help !== null) {
+        return help;
+    }
+    const parsed = parseArgs(argv);
+    if (parsed.error !== undefined) {
+        process.stderr.write(`triage:evaluate: ${parsed.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(parsed.projectRoot);
+    const repo = resolveRepo(parsed.repo, projectRoot);
+    if (repo === null) {
+        process.stderr.write("triage:evaluate: --repo owner/name is required\n");
+        return 2;
+    }
+    try {
+        const result = await evaluateIssues({
+            projectRoot,
+            repo,
+            issues: parsed.issues,
+            concurrency: parsed.concurrency,
+        });
+        if (parsed.json) {
+            process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(renderEvaluateText(result));
+        }
+        return result.verdicts.some((v) => v.error !== null) ? 1 : 0;
+    }
+    catch (err) {
+        const message = err instanceof EvaluateError ? err.message : String(err);
+        process.stderr.write(`triage:evaluate: ${message}\n`);
+        return err instanceof EvaluateError ? 2 : 1;
+    }
+}
+export async function main(argv) {
+    return run(argv);
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    void run(process.argv.slice(2)).then((code) => {
+        process.exit(code);
+    });
+}
+//# sourceMappingURL=triage-evaluate.js.map

package/dist/verify-completed-tracked.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { evaluateCompletedTracked } from "@deftai/directive-core/lifecycle";
+import { COMPLETED_TRACKED_PROGRESS_MIN_BLOBS, COMPLETED_TRACKED_PROGRESS_THRESHOLD_MS, evaluateCompletedTracked, shouldAnnounceProgress, shouldAnnounceUpFrontCount, } from "@deftai/directive-core/lifecycle";
 function parseIssueNumber(raw) {
     const trimmed = raw.startsWith("#") ? raw.slice(1) : raw;
     if (!/^\d+$/.test(trimmed)) {
@@ -95,12 +95,27 @@ export function run(argv) {
         return 2;
     }
     const projectRoot = resolve(args.projectRoot);
+    const thresholdMs = resolveProgressThresholdMs();
+    let announced = false;
     const result = 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);
+        },
     });
     if (result.message.length > 0) {
         if (result.stream === "stdout") {
@@ -112,6 +127,24 @@ export function run(argv) {
     }
     return result.code;
 }
+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)));
 }

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