@deftai/directive-core 0.55.0

package/dist/vbrief-validation/story-quality.js

@@ -0,0 +1,452 @@
+import { stripEdgeChars, stripTrailingChar, stripTrailingWhitespace } from "./normalize.js";
+export const BROAD_FILE_SCOPE_ROOTS = new Set(["backend", "frontend", "docs", "vbrief"]);
+export const CODE_PATH_TERMS = [
+    "api",
+    "cli",
+    "component",
+    "config",
+    "database",
+    "endpoint",
+    "file",
+    "handler",
+    "model",
+    "module",
+    "repository",
+    "route",
+    "schema",
+    "script",
+    "service",
+    "source",
+    "src/",
+];
+export const VERIFY_EVIDENCE_TERMS = [
+    "assert",
+    "evidence",
+    "fixture",
+    "report",
+    "spec",
+    "test",
+    "tests/",
+    "verify",
+];
+export const GENERIC_VERIFY_COMMANDS = new Set([
+    "cargo test",
+    "go test ./...",
+    "npm run test",
+    "npm test",
+    "pytest",
+    "task check",
+]);
+export const PLACEHOLDER_ACCEPTANCE_PATTERNS = [
+    "acceptance criteria for",
+    "copy from parent",
+    "copy from specification",
+    "placeholder",
+    "refine from parent",
+    "tbd",
+    "to be defined",
+    "to refine",
+    "to refine from parent scope",
+    "todo",
+];
+export const DOCS_ONLY_ACCEPTANCE_PATTERNS = [
+    "docs updated",
+    "documentation updated",
+    "readme updated",
+    "update docs",
+    "update documentation",
+    "update readme",
+];
+export const GENERIC_IMPLEMENTATION_PATTERNS = [
+    "add tests so it works",
+    "change the code",
+    "implement the feature",
+    "make it work",
+    "update the code",
+    "works as expected",
+];
+export const VAGUE_ACCEPTANCE_PATTERNS = [
+    "displays a message",
+    "handles errors",
+    "is implemented",
+    "is updated",
+    "passes tests",
+    "shows a message",
+    "the system displays a message",
+    "updates the ui",
+    "works as expected",
+];
+export const OBSERVABLE_TERMS = [
+    "blocks",
+    "creates",
+    "deletes",
+    "displays",
+    "emits",
+    "fails",
+    "persists",
+    "records",
+    "redirects",
+    "rejects",
+    "renders",
+    "returns",
+    "saves",
+    "shows",
+    "stores",
+    "updates",
+    "validates",
+    "when ",
+    "given ",
+    "then ",
+];
+// Linear, ReDoS-free recognizer for the Python USER_STORY_RE:
+//   ^\s*As\s+a[n]?\s+[^,]+,\s*I\s+want\s+.+,\s*so\s+that\s+.+\.\s*$  (IGNORECASE | DOTALL)
+// The two greedy ``.+`` segments under DOTALL are the polynomial-backtracking
+// source (CodeQL js/polynomial-redos). They are only ever consumed by a boolean
+// ``.test()`` (no capture groups), so we replace the regex with an existence
+// check that accepts EXACTLY the same language:
+//   * The bounded, unambiguous prefix (``As a/an <role>, I want``) is matched by a
+//     linear regex -- ``[^,]+`` is followed by ``,`` (excluded from the class) and
+//     every quantified ``\s`` sits next to a literal, so there is no overlapping
+//     adjacent-quantifier backtracking.
+//   * The ``.+,...,.+\.`` tail is verified by scanning for the literal connective
+//     ``, so that`` and a trailing literal period via string ops -- no backtracking.
+// A single mandatory ``\s`` is enough wherever Python wrote ``\s+`` because the
+// following greedy class (``[^,]+`` or DOTALL ``.+``) also matches whitespace, so
+// the extra whitespace folds into it -- the accepted set is identical.
+const USER_STORY_PREFIX_RE = /^\s*As\s+a[n]?\s[^,]+,\s*I\s+want\s/i;
+const SO_THAT_PREFIX_RE = /^\s*so\s+that\s/i;
+// Equivalent of ``^\s*so\s+that\s+.+\.\s*$`` (DOTALL) on the post-comma remainder.
+function matchesSoThatClause(text) {
+    const prefix = SO_THAT_PREFIX_RE.exec(text);
+    if (prefix === null) {
+        return false;
+    }
+    // outcome ``.+`` then literal ``\.`` then ``\s*$``: after stripping trailing
+    // whitespace the remainder must end with ``.`` and carry >=1 outcome char.
+    const outcome = stripTrailingWhitespace(text.slice(prefix[0].length));
+    return outcome.length >= 2 && outcome.endsWith(".");
+}
+// Equivalent of ``.+,\s*so\s+that\s+.+\.\s*$`` (DOTALL): the capability ``.+`` is
+// >=1 char, so try every comma at index >=1 and verify the so-that tail.
+function matchesCapabilityAndOutcome(text) {
+    for (let i = 1; i < text.length; i += 1) {
+        if (text[i] === "," && matchesSoThatClause(text.slice(i + 1))) {
+            return true;
+        }
+    }
+    return false;
+}
+function matchesUserStory(text) {
+    const prefix = USER_STORY_PREFIX_RE.exec(text);
+    if (prefix === null) {
+        return false;
+    }
+    return matchesCapabilityAndOutcome(text.slice(prefix[0].length));
+}
+export function asStrList(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed ? [trimmed] : [];
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => String(item).trim()).filter((item) => item.length > 0);
+    }
+    return [];
+}
+export function acceptanceTextsFromItems(items) {
+    const texts = [];
+    if (!Array.isArray(items)) {
+        return texts;
+    }
+    for (const item of items) {
+        if (typeof item !== "object" || item === null) {
+            continue;
+        }
+        const obj = item;
+        const narrative = obj.narrative;
+        if (typeof narrative === "object" && narrative !== null && !Array.isArray(narrative)) {
+            const acceptance = narrative.Acceptance;
+            if (typeof acceptance === "string" && acceptance.trim()) {
+                texts.push(acceptance.trim());
+            }
+        }
+        for (const childKey of ["items", "subItems"]) {
+            texts.push(...acceptanceTextsFromItems(obj[childKey]));
+        }
+    }
+    return texts;
+}
+export function itemHasAcceptance(item) {
+    const narrative = item.narrative;
+    if (typeof narrative === "object" && narrative !== null && !Array.isArray(narrative)) {
+        const value = narrative.Acceptance;
+        if (typeof value === "string" && value.trim()) {
+            return true;
+        }
+    }
+    for (const childKey of ["items", "subItems"]) {
+        const children = item[childKey];
+        if (Array.isArray(children)) {
+            for (const child of children) {
+                if (typeof child === "object" && child !== null && itemHasAcceptance(child)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+export function itemsHaveAcceptance(items) {
+    if (!Array.isArray(items)) {
+        return false;
+    }
+    return items.some((item) => typeof item === "object" && item !== null && itemHasAcceptance(item));
+}
+export function itemHasTraces(item) {
+    const narrative = item.narrative;
+    if (typeof narrative === "object" && narrative !== null && !Array.isArray(narrative)) {
+        const value = narrative.Traces;
+        if (typeof value === "string" && value.trim()) {
+            return true;
+        }
+    }
+    for (const childKey of ["items", "subItems"]) {
+        const children = item[childKey];
+        if (Array.isArray(children)) {
+            for (const child of children) {
+                if (typeof child === "object" && child !== null && itemHasTraces(child)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+export function missingRequiredSwarmFields(swarm) {
+    const missing = [];
+    for (const key of ["file_scope", "verify_commands", "expected_outputs"]) {
+        if (asStrList(swarm[key]).length === 0) {
+            missing.push(`plan.metadata.swarm.${key}`);
+        }
+    }
+    if (!("depends_on" in swarm)) {
+        missing.push("plan.metadata.swarm.depends_on");
+    }
+    for (const key of ["conflict_group", "size", "file_scope_confidence", "model_tier"]) {
+        const value = swarm[key];
+        if (typeof value !== "string" || !value.trim()) {
+            missing.push(`plan.metadata.swarm.${key}`);
+        }
+    }
+    return missing;
+}
+export function deprecatedSubitemsIssues(items, prefix = "plan.items") {
+    const issues = [];
+    const visit = (children, path) => {
+        if (!Array.isArray(children)) {
+            return;
+        }
+        for (let index = 0; index < children.length; index += 1) {
+            const item = children[index];
+            if (typeof item !== "object" || item === null) {
+                continue;
+            }
+            const obj = item;
+            const itemPath = `${path}[${index}]`;
+            if ("subItems" in obj) {
+                issues.push(`${itemPath}.subItems is deprecated; use items`);
+            }
+            visit(obj.items, `${itemPath}.items`);
+            visit(obj.subItems, `${itemPath}.subItems`);
+        }
+    };
+    visit(items, prefix);
+    return issues;
+}
+export function storyQualityIssues(params) {
+    const issues = [];
+    const concurrentReady = params.concurrentReady ?? true;
+    if (!matchesUserStory(params.userStory ?? "")) {
+        issues.push("UserStory must match 'As a <role>, I want <capability>, so that <outcome>.'");
+    }
+    issues.push(...descriptionIssues(params.description));
+    issues.push(...implementationPlanIssues(params.implementationPlan));
+    if (!(params.acceptanceTexts.length >= 2 && params.acceptanceTexts.length <= 5) &&
+        !params.acceptanceCountJustification.trim()) {
+        issues.push("2-5 acceptance criteria required unless justified");
+    }
+    const normalizedTitle = normalize(params.title);
+    const normalizedDescription = normalize(params.description);
+    for (const criterion of params.acceptanceTexts) {
+        const normalized = normalize(criterion);
+        const lower = criterion.toLowerCase();
+        if (PLACEHOLDER_ACCEPTANCE_PATTERNS.some((pattern) => lower.includes(pattern))) {
+            issues.push("placeholder acceptance criterion");
+        }
+        if (normalized && (normalized === normalizedTitle || normalized === normalizedDescription)) {
+            issues.push("acceptance criterion duplicates title or description");
+        }
+        if (DOCS_ONLY_ACCEPTANCE_PATTERNS.some((pattern) => lower.includes(pattern))) {
+            issues.push("vague docs-only acceptance criterion");
+        }
+        if (wordCount(criterion) < 8 ||
+            VAGUE_ACCEPTANCE_PATTERNS.some((pattern) => lower.includes(pattern))) {
+            issues.push("acceptance criterion must describe specific observable behavior");
+        }
+        if (!looksObservable(lower)) {
+            issues.push("acceptance criterion must describe observable behavior");
+        }
+    }
+    if (concurrentReady) {
+        issues.push(...fileScopeIssues(params.swarm));
+        issues.push(...verifyCommandIssues(params.swarm));
+        if (params.swarm.parallel_safe === false) {
+            issues.push("readiness=ready requires parallel_safe=true; use readiness=sequential or needs_refinement for non-concurrent work");
+        }
+        if (params.swarm.file_scope_confidence === "low") {
+            issues.push("readiness=ready requires file_scope_confidence above low");
+        }
+    }
+    return dedupe(issues);
+}
+function fileScopeIssues(swarm) {
+    const issues = [];
+    for (const filePath of asStrList(swarm.file_scope)) {
+        const normalized = stripEdgeChars(filePath.trim(), "/");
+        const root = normalized.split("/", 1)[0] ?? "";
+        if (/[*?[]/.test(normalized) ||
+            BROAD_FILE_SCOPE_ROOTS.has(normalized) ||
+            BROAD_FILE_SCOPE_ROOTS.has(stripTrailingChar(filePath, "/")) ||
+            (BROAD_FILE_SCOPE_ROOTS.has(root) && (normalized === root || normalized === `${root}/*`))) {
+            issues.push(`broad file_scope is not swarm-ready: ${filePath}`);
+        }
+    }
+    return issues;
+}
+function verifyCommandIssues(swarm) {
+    const commands = asStrList(swarm.verify_commands).map((command) => command.toLowerCase());
+    if (commands.length === 1 && GENERIC_VERIFY_COMMANDS.has(normalizeCommand(commands[0] ?? ""))) {
+        return [`generic verify command is not swarm-ready: ${commands[0]}`];
+    }
+    return [];
+}
+function descriptionIssues(description) {
+    if (!description.trim()) {
+        return ["plan.narratives.Description is required"];
+    }
+    if (sentenceCount(description) < 2 || wordCount(description) < 20) {
+        return ["plan.narratives.Description must contain at least two concrete sentences"];
+    }
+    return [];
+}
+function implementationPlanIssues(implementationPlan) {
+    if (!implementationPlan.trim()) {
+        return ["plan.narratives.ImplementationPlan is required"];
+    }
+    const issues = [];
+    if (stepCount(implementationPlan) < 2 || wordCount(implementationPlan) < 20) {
+        issues.push("plan.narratives.ImplementationPlan must contain at least two concrete steps");
+    }
+    const lower = implementationPlan.toLowerCase();
+    if (PLACEHOLDER_ACCEPTANCE_PATTERNS.some((pattern) => lower.includes(pattern))) {
+        issues.push("plan.narratives.ImplementationPlan must not be placeholder text");
+    }
+    if (GENERIC_IMPLEMENTATION_PATTERNS.some((pattern) => lower.includes(pattern)) ||
+        !(CODE_PATH_TERMS.some((term) => lower.includes(term)) &&
+            VERIFY_EVIDENCE_TERMS.some((term) => lower.includes(term)))) {
+        issues.push("plan.narratives.ImplementationPlan must identify concrete code paths and verification evidence");
+    }
+    return issues;
+}
+function looksObservable(lower) {
+    return OBSERVABLE_TERMS.some((term) => lower.includes(term));
+}
+function sentenceCount(value) {
+    // Equivalent of ``value.trim().split(/[.!?]+(?:\s+|$)/).filter(non-empty-trim).length``
+    // implemented as a linear scan to avoid the ReDoS-prone ``[.!?]+(?:\s+|$)``
+    // (CodeQL js/polynomial-redos). A segment boundary is a maximal run of
+    // ``[.!?]`` immediately followed by whitespace or end-of-string.
+    const trimmed = value.trim();
+    let count = 0;
+    let segmentHasContent = false;
+    let i = 0;
+    while (i < trimmed.length) {
+        const ch = trimmed[i];
+        if (ch === "." || ch === "!" || ch === "?") {
+            let j = i + 1;
+            while (j < trimmed.length) {
+                const next = trimmed[j];
+                if (next === "." || next === "!" || next === "?") {
+                    j += 1;
+                }
+                else {
+                    break;
+                }
+            }
+            const boundary = j >= trimmed.length || /\s/.test(trimmed[j]);
+            if (boundary) {
+                if (segmentHasContent) {
+                    count += 1;
+                }
+                segmentHasContent = false;
+                i = j;
+                while (i < trimmed.length && /\s/.test(trimmed[i])) {
+                    i += 1;
+                }
+                continue;
+            }
+            // Terminators not followed by whitespace/end are ordinary segment content.
+            segmentHasContent = true;
+            i = j;
+            continue;
+        }
+        if (!/\s/.test(ch)) {
+            segmentHasContent = true;
+        }
+        i += 1;
+    }
+    if (segmentHasContent) {
+        count += 1;
+    }
+    return count;
+}
+function stepCount(value) {
+    const lines = value
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const bulletLines = lines.filter((line) => /^([-*]|\d+[.)])\s+/.test(line));
+    if (bulletLines.length >= 2) {
+        return bulletLines.length;
+    }
+    return sentenceCount(value);
+}
+function wordCount(value) {
+    const matches = value.match(/\b\w+\b/g);
+    return matches?.length ?? 0;
+}
+function normalize(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, " ")
+        .trim();
+}
+function normalizeCommand(value) {
+    return value.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function dedupe(values) {
+    const out = [];
+    const seen = new Set();
+    for (const value of values) {
+        if (seen.has(value)) {
+            continue;
+        }
+        seen.add(value);
+        out.push(value);
+    }
+    return out;
+}
+//# sourceMappingURL=story-quality.js.map

package/dist/vbrief-validation/types.d.ts

@@ -0,0 +1,58 @@
+export type JsonObject = Record<string, unknown>;
+export type SectionTuple = readonly [title: string, body: string, start: number, end: number];
+export interface SpecTask {
+    task_id: string;
+    title: string;
+    status: string;
+    body: string;
+    depends_on: string[];
+    traces: string[];
+    acceptance: string[];
+    start_line: number;
+    end_line: number;
+}
+export interface MigrationLogEntry {
+    source: string;
+    section_title: string;
+    line_range: string;
+    target_key: string;
+    target_file: string;
+}
+export interface BackupRecord {
+    source: string;
+    backup: string;
+    source_sha256: string;
+    size_bytes: number;
+}
+export interface FileModification {
+    path: string;
+    operation: string;
+    pre_hash: string;
+    post_hash: string;
+    appended_content: string;
+}
+export interface RenameRecord {
+    original: string;
+    current: string;
+    renamed_by: string;
+    renamed_at: string;
+}
+export interface SafetyManifestData {
+    version: string;
+    migration_timestamp: string;
+    backups: BackupRecord[];
+    created_files: string[];
+    created_dirs: string[];
+    post_migration_stub_hashes: Record<string, string>;
+    renames: RenameRecord[];
+    file_modifications: FileModification[];
+}
+export interface FinalizeMigrationOptions {
+    readonly stderrWriter?: (chunk: string) => void;
+    readonly isolateInvalid?: typeof import("./validation.js").isolateInvalidOutput;
+}
+export interface RollbackOptions {
+    readonly force?: boolean;
+    readonly confirmFn?: (prompt: string) => boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/vbrief-validation/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/vbrief-validation/validation.d.ts

@@ -0,0 +1,15 @@
+import type { FinalizeMigrationOptions, JsonObject } from "./types.js";
+export declare const RECOVERY_HINT = "Restore with: task migrate:vbrief -- --rollback";
+export declare const ID_MAX_LENGTH = 80;
+export declare const HASH_SUFFIX_LENGTH = 6;
+/** Return a slug-safe id for filenames and in-JSON id fields (#498). */
+export declare function slugifyId(raw: string | null | undefined, existing?: Set<string>): string;
+/** Return the logical identifier source for a scope item dict. */
+export declare function slugFallbackId(item: JsonObject): string;
+/** Validate every file emitted by the migrator under ``vbriefDir``. */
+export declare function validateMigrationOutput(vbriefDir: string): readonly [string[], string[]];
+/** Move the emitted ``vbrief/`` tree to ``vbrief.invalid/`` on failure. */
+export declare function isolateInvalidOutput(projectRoot: string, vbriefDir: string): string | null;
+/** Run validation + isolation as the migrator's terminal gate (#498). */
+export declare function finalizeMigration(projectRoot: string, vbriefDir: string, actions: string[], options?: FinalizeMigrationOptions): readonly [boolean, string[]];
+//# sourceMappingURL=validation.d.ts.map

package/dist/vbrief-validation/validation.js

@@ -0,0 +1,123 @@
+import { createHash } from "node:crypto";
+import { existsSync, renameSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+import { validateAllMigration } from "../vbrief-validate/validate-all.js";
+import { stripEdgeChars, stripTrailingChar } from "./normalize.js";
+export const RECOVERY_HINT = "Restore with: task migrate:vbrief -- --rollback";
+export const ID_MAX_LENGTH = 80;
+export const HASH_SUFFIX_LENGTH = 6;
+/** Return a slug-safe id for filenames and in-JSON id fields (#498). */
+export function slugifyId(raw, existing) {
+    const text = (raw ?? "").trim();
+    let slug = text.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    slug = stripEdgeChars(slug, "-");
+    if (!slug) {
+        slug = "untitled";
+    }
+    if (slug.length > ID_MAX_LENGTH) {
+        slug = stripTrailingChar(slug.slice(0, ID_MAX_LENGTH), "-") || slug.slice(0, ID_MAX_LENGTH);
+    }
+    if (existing === undefined) {
+        return slug;
+    }
+    if (!existing.has(slug)) {
+        existing.add(slug);
+        return slug;
+    }
+    const digestSeed = text || slug;
+    const baseMax = ID_MAX_LENGTH - 1 - HASH_SUFFIX_LENGTH;
+    const base = slug.slice(0, baseMax).replace(/-+$/, "") || slug.slice(0, baseMax) || "id";
+    let h = createHash("sha1").update(digestSeed, "utf8").digest("hex").slice(0, HASH_SUFFIX_LENGTH);
+    let candidate = `${base}-${h}`;
+    let attempt = 0;
+    while (existing.has(candidate) && attempt < 1000) {
+        attempt += 1;
+        h = createHash("sha1")
+            .update(`${digestSeed}|${attempt}`, "utf8")
+            .digest("hex")
+            .slice(0, HASH_SUFFIX_LENGTH);
+        candidate = `${base}-${h}`;
+    }
+    existing.add(candidate);
+    return candidate;
+}
+/** Return the logical identifier source for a scope item dict. */
+export function slugFallbackId(item) {
+    const number = String(item.number ?? "").trim();
+    if (number) {
+        return number;
+    }
+    const taskId = String(item.task_id ?? "").trim();
+    if (taskId) {
+        return taskId;
+    }
+    const synthetic = String(item.synthetic_id ?? "").trim();
+    if (synthetic) {
+        return synthetic;
+    }
+    return String(item.title ?? "").trim() || "untitled";
+}
+/** Validate every file emitted by the migrator under ``vbriefDir``. */
+export function validateMigrationOutput(vbriefDir) {
+    try {
+        if (!statSync(vbriefDir).isDirectory()) {
+            return [[`${vbriefDir}: expected vbrief directory does not exist`], []];
+        }
+    }
+    catch {
+        return [[`${vbriefDir}: expected vbrief directory does not exist`], []];
+    }
+    const [errors, warnings] = validateAllMigration(vbriefDir);
+    return [[...errors], [...warnings]];
+}
+/** Move the emitted ``vbrief/`` tree to ``vbrief.invalid/`` on failure. */
+export function isolateInvalidOutput(projectRoot, vbriefDir) {
+    if (!existsSync(vbriefDir)) {
+        return null;
+    }
+    let target = join(projectRoot, "vbrief.invalid");
+    let idx = 1;
+    while (existsSync(target)) {
+        idx += 1;
+        target = join(projectRoot, `vbrief.invalid.${idx}`);
+    }
+    renameSync(vbriefDir, target);
+    return target;
+}
+/** Run validation + isolation as the migrator's terminal gate (#498). */
+export function finalizeMigration(projectRoot, vbriefDir, actions, options = {}) {
+    const stderrWriter = options.stderrWriter ?? ((chunk) => process.stderr.write(chunk));
+    const isolateFn = options.isolateInvalid ?? isolateInvalidOutput;
+    const [errors, warnings] = validateMigrationOutput(vbriefDir);
+    if (errors.length === 0) {
+        for (const w of warnings) {
+            stderrWriter(`WARNING: ${w}\n`);
+        }
+        return [true, actions];
+    }
+    stderrWriter(`ERROR: Migration produced invalid output (${errors.length} file-level error(s)):\n`);
+    for (const err of errors) {
+        stderrWriter(`  ${err}\n`);
+    }
+    const invalidDir = isolateFn(projectRoot, vbriefDir);
+    const failureActions = [...actions];
+    failureActions.push(`FAIL  migration produced ${errors.length} schema validation error(s)`);
+    for (const err of errors) {
+        failureActions.push(`  ${err}`);
+    }
+    if (invalidDir !== null) {
+        let relInvalid;
+        try {
+            relInvalid = relative(projectRoot, invalidDir).split("\\").join("/");
+        }
+        catch {
+            relInvalid = invalidDir;
+        }
+        failureActions.push(`MOVE  vbrief/ -> ${relInvalid}/ (isolated from vbrief/)`);
+        stderrWriter(`Isolated partial output to: ${relInvalid}\n`);
+    }
+    failureActions.push(RECOVERY_HINT);
+    stderrWriter(`${RECOVERY_HINT}\n`);
+    return [false, failureActions];
+}
+//# sourceMappingURL=validation.js.map

package/dist/verify-env/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./node-runtime.js";
+export * from "./toolchain-check.js";
+export * from "./verify-hooks-installed.js";
+export * from "./verify-no-task-runtime.js";
+export * from "./verify-tools.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/verify-env/index.js

@@ -0,0 +1,6 @@
+export * from "./node-runtime.js";
+export * from "./toolchain-check.js";
+export * from "./verify-hooks-installed.js";
+export * from "./verify-no-task-runtime.js";
+export * from "./verify-tools.js";
+//# sourceMappingURL=index.js.map

package/dist/verify-env/node-runtime.d.ts

@@ -0,0 +1,6 @@
+/** Node/pnpm presence contract for TS-backed consumer gates (#1828 / #1530). */
+export declare const NODE_RUNTIME_TOOL_NAMES: readonly ["node", "pnpm"];
+export declare const NODE_RUNTIME_REMEDIATION = "Node.js and pnpm are required for TS-backed deft gates. Install Node 20+ (see .nvmrc), then run: corepack enable && corepack prepare pnpm@latest --activate. See UPGRADING.md \u00A7 Node runtime.";
+/** Append remediation lines when node or pnpm is among the missing tools. */
+export declare function nodeRuntimeRemediationLines(failed: readonly string[]): readonly string[];
+//# sourceMappingURL=node-runtime.d.ts.map

package/dist/verify-env/node-runtime.js

@@ -0,0 +1,11 @@
+/** Node/pnpm presence contract for TS-backed consumer gates (#1828 / #1530). */
+export const NODE_RUNTIME_TOOL_NAMES = ["node", "pnpm"];
+export const NODE_RUNTIME_REMEDIATION = "Node.js and pnpm are required for TS-backed deft gates. Install Node 20+ (see .nvmrc), then run: corepack enable && corepack prepare pnpm@latest --activate. See UPGRADING.md § Node runtime.";
+/** Append remediation lines when node or pnpm is among the missing tools. */
+export function nodeRuntimeRemediationLines(failed) {
+    if (failed.some((name) => NODE_RUNTIME_TOOL_NAMES.includes(name))) {
+        return [NODE_RUNTIME_REMEDIATION];
+    }
+    return [];
+}
+//# sourceMappingURL=node-runtime.js.map