@deftai/directive-core 0.55.0

package/dist/vbrief-validate/conformance.js

@@ -0,0 +1,273 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { GitCommandError, GitNotFoundError, gitStagedFiles, gitTrackedFiles, } from "../encoding/git.js";
+import { fnmatchCase } from "../encoding/text.js";
+export const DOC_CORE = new Set(["vBRIEFInfo", "plan"]);
+export const PLAN_CORE = new Set([
+    "id",
+    "uid",
+    "title",
+    "status",
+    "items",
+    "narratives",
+    "architecture",
+    "edges",
+    "tags",
+    "metadata",
+    "created",
+    "updated",
+    "author",
+    "reviewers",
+    "uris",
+    "references",
+    "timezone",
+    "agent",
+    "lastModifiedBy",
+    "changeLog",
+    "sequence",
+    "fork",
+]);
+export const ITEM_CORE = new Set([
+    "id",
+    "uid",
+    "title",
+    "status",
+    "narrative",
+    "subItems",
+    "planRef",
+    "tags",
+    "metadata",
+    "created",
+    "updated",
+    "completed",
+    "priority",
+    "dueDate",
+    "startDate",
+    "endDate",
+    "percentComplete",
+    "participants",
+    "location",
+    "uris",
+    "recurrence",
+    "reminders",
+    "classification",
+    "relatedComments",
+    "timezone",
+    "sequence",
+    "lastModifiedBy",
+    "lockedBy",
+    "items",
+]);
+export const EXTENSION_PREFIXES = ["x-directive/", "x-vbrief/"];
+export const ALLOW_LIST = new Set(["plan.policy", "plan.completedNote"]);
+export function renderFinding(finding) {
+    return `  ${finding.path} [${finding.level}] bare key '${finding.key}' at ${finding.location}`;
+}
+function isConformant(level, key, core) {
+    if (core.has(key)) {
+        return true;
+    }
+    for (const prefix of EXTENSION_PREFIXES) {
+        if (key.startsWith(prefix)) {
+            return true;
+        }
+    }
+    return ALLOW_LIST.has(`${level}.${key}`);
+}
+function planPlanRefFinding(relPath, value) {
+    if (typeof value === "string" && value.trim().startsWith("#")) {
+        return {
+            path: relPath,
+            level: "plan",
+            key: "planRef",
+            location: "plan (issue-style -- migrate to references[])",
+        };
+    }
+    return null;
+}
+function scanItem(relPath, item, location) {
+    const findings = [];
+    for (const key of Object.keys(item)) {
+        if (!isConformant("item", key, ITEM_CORE)) {
+            findings.push({ path: relPath, level: "item", key, location });
+        }
+    }
+    for (const nestedKey of ["items", "subItems"]) {
+        const nested = item[nestedKey];
+        if (Array.isArray(nested)) {
+            for (let index = 0; index < nested.length; index += 1) {
+                const child = nested[index];
+                if (typeof child === "object" && child !== null && !Array.isArray(child)) {
+                    findings.push(...scanItem(relPath, child, `${location}.${nestedKey}[${index}]`));
+                }
+            }
+        }
+    }
+    return findings;
+}
+/** Scan a parsed vBRIEF document for bare keys at doc / plan / item level (#1620). */
+export function scanVbrief(relPath, data) {
+    const findings = [];
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+        return findings;
+    }
+    const doc = data;
+    for (const key of Object.keys(doc)) {
+        if (!isConformant("document", key, DOC_CORE)) {
+            findings.push({ path: relPath, level: "document", key, location: "<root>" });
+        }
+    }
+    const plan = doc.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return findings;
+    }
+    const planObj = plan;
+    for (const key of Object.keys(planObj)) {
+        if (key === "planRef") {
+            const hit = planPlanRefFinding(relPath, planObj.planRef);
+            if (hit !== null) {
+                findings.push(hit);
+            }
+            continue;
+        }
+        if (!isConformant("plan", key, PLAN_CORE)) {
+            findings.push({ path: relPath, level: "plan", key, location: "plan" });
+        }
+    }
+    const items = planObj.items;
+    if (Array.isArray(items)) {
+        for (let index = 0; index < items.length; index += 1) {
+            const item = items[index];
+            if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+                findings.push(...scanItem(relPath, item, `plan.items[${index}]`));
+            }
+        }
+    }
+    return findings;
+}
+function loadAllowList(path) {
+    if (path === null) {
+        return [];
+    }
+    const raw = readFileSync(path, "utf8");
+    const out = [];
+    for (const line of raw.split("\n")) {
+        const stripped = line.trim();
+        if (!stripped || stripped.startsWith("#")) {
+            continue;
+        }
+        out.push(stripped);
+    }
+    return out;
+}
+function isAllowListed(relPath, patterns) {
+    return patterns.some((pat) => fnmatchCase(relPath, pat));
+}
+function isVbriefPath(posix) {
+    return posix.startsWith("vbrief/") && posix.endsWith(".vbrief.json");
+}
+/** Pure driver returning exit code, findings, and human message. */
+export function evaluateConformance(projectRoot, options = {}) {
+    const mode = options.mode ?? "all";
+    const root = resolve(projectRoot);
+    if (mode !== "all" && mode !== "staged") {
+        return {
+            exitCode: 2,
+            findings: [],
+            message: `\u274c verify_vbrief_conformance: unrecognised mode '${mode}' ` +
+                "(expected 'all' or 'staged').",
+        };
+    }
+    if (!existsSync(join(root, "vbrief"))) {
+        return {
+            exitCode: 2,
+            findings: [],
+            message: `\u274c verify_vbrief_conformance: no vbrief/ directory under ` +
+                `${root}.\n` +
+                "  Recovery: run from a project root that contains vbrief/.",
+        };
+    }
+    let customGlobs;
+    try {
+        customGlobs = loadAllowList(options.allowListPath ?? null);
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === "ENOENT") {
+            return {
+                exitCode: 2,
+                findings: [],
+                message: `\u274c verify_vbrief_conformance: --allow-list file not found: Error: ENOENT: no such file or directory, open '${options.allowListPath}'\n` +
+                    "  Recovery: pass an existing path or omit the flag.",
+            };
+        }
+        return {
+            exitCode: 2,
+            findings: [],
+            message: `\u274c verify_vbrief_conformance: --allow-list unreadable: ${e.message ?? err}`,
+        };
+    }
+    let relPaths;
+    try {
+        relPaths = mode === "staged" ? gitStagedFiles(root) : gitTrackedFiles(root);
+    }
+    catch (err) {
+        if (err instanceof GitNotFoundError) {
+            return {
+                exitCode: 2,
+                findings: [],
+                message: "\u274c verify_vbrief_conformance: 'git' executable not found on PATH.",
+            };
+        }
+        if (err instanceof GitCommandError) {
+            return {
+                exitCode: 2,
+                findings: [],
+                message: `\u274c verify_vbrief_conformance: git failed -- ${err.message}\n` +
+                    "  Recovery: ensure --project-root points at a git working tree.",
+            };
+        }
+        throw err;
+    }
+    const candidates = relPaths
+        .map((p) => p.replace(/\\/g, "/"))
+        .filter((posix) => isVbriefPath(posix) && !isAllowListed(posix, customGlobs));
+    const findings = [];
+    for (const posix of candidates) {
+        const full = join(root, posix);
+        let text;
+        try {
+            text = readFileSync(full, "utf8");
+        }
+        catch {
+            continue;
+        }
+        try {
+            findings.push(...scanVbrief(posix, JSON.parse(text)));
+        }
+        catch { }
+    }
+    if (findings.length > 0) {
+        const uniquePaths = new Set(findings.map((f) => f.path));
+        const header = `\u274c verify_vbrief_conformance: detected ${findings.length} bare ` +
+            `key(s) across ${uniquePaths.size} file(s) (#1620).\n` +
+            "  Every vBRIEF key MUST be 0.6 spec-core, x-directive/-namespaced, " +
+            "or x-vbrief/-namespaced -- never bare.\n" +
+            "  Fix: migrate misused/misspelled core fields to their core home " +
+            "(see scripts/vbrief_migrate_conformance.py), or namespace a genuine\n" +
+            "  extension under x-directive/. Allow-list a documented file " +
+            "exception via --allow-list <path> (newline-separated globs).";
+        let body = findings.slice(0, 50).map(renderFinding).join("\n");
+        if (findings.length > 50) {
+            body += `\n  ... and ${findings.length - 50} more`;
+        }
+        return { exitCode: 1, findings, message: `${header}\n${body}` };
+    }
+    return {
+        exitCode: 0,
+        findings,
+        message: `\u2713 verify_vbrief_conformance: ${candidates.length} vBRIEF file(s) ` +
+            "clean -- no bare keys (#1620).",
+    };
+}
+//# sourceMappingURL=conformance.js.map

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

@@ -0,0 +1,13 @@
+/** v0.6 Status enum from the canonical schema. */
+export declare const VALID_STATUSES: Set<string>;
+export declare const VALID_VBRIEF_VERSIONS: Set<string>;
+/** D13: status-to-folder mapping (#533 adds ``failed`` in completed/). */
+export declare const FOLDER_ALLOWED_STATUSES: Readonly<Record<string, ReadonlySet<string>>>;
+export declare const LIFECYCLE_FOLDERS: string[];
+/** D3: expected narrative keys for PROJECT-DEFINITION (normalized). */
+export declare const PROJECT_DEF_EXPECTED_NARRATIVES: Set<string>;
+export declare const STRICT_ORIGIN_ALLOWLIST: Set<string>;
+export declare const LEGACY_ORIGIN_TYPES: Set<string>;
+export declare const DEPRECATED_FILES: readonly ["SPECIFICATION.md", "PROJECT.md"];
+export declare const USAGE = "Usage: vbrief_validate.py [--vbrief-dir <path>] [--strict-origin-types] [--warnings-as-errors]";
+//# sourceMappingURL=constants.d.ts.map

package/dist/vbrief-validate/constants.js

@@ -0,0 +1,36 @@
+/** v0.6 Status enum from the canonical schema. */
+export const VALID_STATUSES = new Set([
+    "draft",
+    "proposed",
+    "approved",
+    "pending",
+    "running",
+    "completed",
+    "blocked",
+    "failed",
+    "cancelled",
+]);
+export const VALID_VBRIEF_VERSIONS = new Set(["0.6"]);
+/** D13: status-to-folder mapping (#533 adds ``failed`` in completed/). */
+export const FOLDER_ALLOWED_STATUSES = {
+    proposed: new Set(["draft", "proposed"]),
+    pending: new Set(["approved", "pending"]),
+    active: new Set(["running", "blocked"]),
+    completed: new Set(["completed", "failed"]),
+    cancelled: new Set(["cancelled"]),
+};
+export const LIFECYCLE_FOLDERS = Object.keys(FOLDER_ALLOWED_STATUSES);
+/** D3: expected narrative keys for PROJECT-DEFINITION (normalized). */
+export const PROJECT_DEF_EXPECTED_NARRATIVES = new Set(["overview", "techstack"]);
+export const STRICT_ORIGIN_ALLOWLIST = new Set([
+    "x-vbrief/plan",
+    "x-vbrief/github-issue",
+    "x-vbrief/github-pr",
+    "x-vbrief/jira-ticket",
+    "x-vbrief/user-request",
+    "x-vbrief/spec-section",
+]);
+export const LEGACY_ORIGIN_TYPES = new Set(["github-issue", "jira-ticket", "user-request"]);
+export const DEPRECATED_FILES = ["SPECIFICATION.md", "PROJECT.md"];
+export const USAGE = "Usage: vbrief_validate.py [--vbrief-dir <path>] [--strict-origin-types] [--warnings-as-errors]";
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1,3 @@
+/** Reject decomposition draft proposals left at the workspace root. */
+export declare function validateNoRootDecompositionDrafts(vbriefDir: string): string[];
+//# sourceMappingURL=decomposition.d.ts.map

package/dist/vbrief-validate/decomposition.js

@@ -0,0 +1,38 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+function looksLikeDecompositionDraft(data) {
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+        return false;
+    }
+    const obj = data;
+    const stories = obj.stories ?? obj.children;
+    return Array.isArray(stories) || (typeof stories === "object" && stories !== null);
+}
+/** Reject decomposition draft proposals left at the workspace root. */
+export function validateNoRootDecompositionDrafts(vbriefDir) {
+    const projectRoot = resolve(vbriefDir, "..");
+    const errors = [];
+    let entries;
+    try {
+        entries = readdirSync(projectRoot).filter((name) => name.endsWith(".json"));
+    }
+    catch {
+        return errors;
+    }
+    for (const name of [...entries].sort()) {
+        const path = join(projectRoot, name);
+        let data;
+        try {
+            data = JSON.parse(readFileSync(path, "utf8"));
+        }
+        catch {
+            continue;
+        }
+        if (looksLikeDecompositionDraft(data)) {
+            errors.push(`${path}: decomposition draft JSON must not live at workspace root; ` +
+                "write temporary proposals under vbrief/.eval/decompositions/");
+        }
+    }
+    return errors;
+}
+//# sourceMappingURL=decomposition.js.map

package/dist/vbrief-validate/epic-links.d.ts

@@ -0,0 +1,4 @@
+import type { JsonObject } from "./schema.js";
+/** Validate bidirectional references between epic and story vBRIEFs (D4). */
+export declare function validateEpicStoryLinks(allVbriefs: ReadonlyMap<string, JsonObject>, vbriefDir: string, resolvedToOriginal: ReadonlyMap<string, string>): string[];
+//# sourceMappingURL=epic-links.d.ts.map

package/dist/vbrief-validate/epic-links.js

@@ -0,0 +1,152 @@
+import { existsSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { resolveRefPath } from "./paths.js";
+function collectPlanRefs(plan) {
+    const refs = [];
+    const rootRef = plan.planRef;
+    if (typeof rootRef === "string" && rootRef) {
+        refs.push(rootRef);
+    }
+    const items = plan.items;
+    if (Array.isArray(items)) {
+        for (const item of items) {
+            if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+                const itemRef = item.planRef;
+                if (typeof itemRef === "string" && itemRef) {
+                    refs.push(itemRef);
+                }
+            }
+        }
+    }
+    return refs;
+}
+function hasPlanRefTo(childPlan, parentPath, vbriefDir) {
+    const planRef = childPlan.planRef;
+    if (typeof planRef === "string" && planRef) {
+        const resolved = resolveRefPath(planRef, vbriefDir);
+        if (resolved !== null && resolve(resolved) === resolve(parentPath)) {
+            return true;
+        }
+    }
+    const items = childPlan.items;
+    if (Array.isArray(items)) {
+        for (const item of items) {
+            if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+                const itemRef = item.planRef;
+                if (typeof itemRef === "string" && itemRef) {
+                    const resolved = resolveRefPath(itemRef, vbriefDir);
+                    if (resolved !== null && resolve(resolved) === resolve(parentPath)) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+function pathInRefs(filepath, uris, vbriefDir) {
+    const resolvedFile = resolve(filepath);
+    for (const uri of uris) {
+        const resolved = resolveRefPath(uri, vbriefDir);
+        if (resolved !== null && resolve(resolved) === resolvedFile) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Validate bidirectional references between epic and story vBRIEFs (D4). */
+export function validateEpicStoryLinks(allVbriefs, vbriefDir, resolvedToOriginal) {
+    const errors = [];
+    const display = (p) => resolvedToOriginal.get(p) ?? p;
+    for (const [filepath, data] of allVbriefs) {
+        const plan = data.plan;
+        if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+            continue;
+        }
+        const planObj = plan;
+        const fpDisplay = display(filepath);
+        const refs = planObj.references;
+        if (Array.isArray(refs)) {
+            for (const ref of refs) {
+                if (typeof ref !== "object" || ref === null || Array.isArray(ref)) {
+                    continue;
+                }
+                const refObj = ref;
+                const uri = refObj.uri;
+                const refType = refObj.type;
+                if (typeof uri !== "string" || !uri || typeof refType !== "string" || !refType) {
+                    continue;
+                }
+                if (refType !== "x-vbrief/plan") {
+                    continue;
+                }
+                const childPath = resolveRefPath(uri, vbriefDir);
+                if (childPath === null) {
+                    continue;
+                }
+                const resolvedChild = resolve(childPath);
+                if (!allVbriefs.has(resolvedChild)) {
+                    if (existsSync(resolvedChild)) {
+                        continue;
+                    }
+                    errors.push(`${fpDisplay}: references child '${uri}' which does not exist (D4)`);
+                    continue;
+                }
+                const childData = allVbriefs.get(resolvedChild);
+                if (childData === undefined) {
+                    continue;
+                }
+                const childPlan = childData.plan;
+                if (typeof childPlan !== "object" || childPlan === null || Array.isArray(childPlan)) {
+                    continue;
+                }
+                if (!hasPlanRefTo(childPlan, filepath, vbriefDir)) {
+                    errors.push(`${display(resolvedChild)}: missing planRef back ` +
+                        `to parent '${basename(display(filepath))}' (D4)`);
+                }
+            }
+        }
+        for (const planRef of collectPlanRefs(planObj)) {
+            const parentPath = resolveRefPath(planRef, vbriefDir);
+            if (parentPath !== null) {
+                const resolvedParent = resolve(parentPath);
+                if (allVbriefs.has(resolvedParent)) {
+                    const parentData = allVbriefs.get(resolvedParent);
+                    if (parentData !== undefined) {
+                        const parentPlan = parentData.plan;
+                        if (typeof parentPlan === "object" &&
+                            parentPlan !== null &&
+                            !Array.isArray(parentPlan)) {
+                            const parentRefs = parentPlan.references;
+                            if (Array.isArray(parentRefs)) {
+                                const childUris = new Set();
+                                for (const pref of parentRefs) {
+                                    if (typeof pref === "object" &&
+                                        pref !== null &&
+                                        !Array.isArray(pref) &&
+                                        pref.type === "x-vbrief/plan") {
+                                        const u = pref.uri;
+                                        if (typeof u === "string") {
+                                            childUris.add(u);
+                                        }
+                                    }
+                                }
+                                if (!pathInRefs(filepath, childUris, vbriefDir)) {
+                                    errors.push(`${fpDisplay}: has planRef to ` +
+                                        `'${basename(resolvedParent)}' but parent ` +
+                                        "does not list this file in " +
+                                        "references (D4)");
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (!existsSync(resolvedParent)) {
+                    errors.push(`${fpDisplay}: planRef references '${planRef}' which does not exist (D4)`);
+                }
+            }
+        }
+    }
+    return errors;
+}
+//# sourceMappingURL=epic-links.js.map

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

@@ -0,0 +1,5 @@
+/** D7: filename convention without polynomial regex (#1782 s3). */
+export declare function matchesFilenameConvention(name: string): boolean;
+/** Check filename matches YYYY-MM-DD-descriptive-slug.vbrief.json (D7). */
+export declare function validateFilename(filepath: string): string[];
+//# sourceMappingURL=filename.d.ts.map

package/dist/vbrief-validate/filename.js

@@ -0,0 +1,62 @@
+/** D7: filename convention without polynomial regex (#1782 s3). */
+export function matchesFilenameConvention(name) {
+    if (!name.endsWith(".vbrief.json")) {
+        return false;
+    }
+    const stem = name.slice(0, -".vbrief.json".length);
+    if (stem.length < 12) {
+        return false;
+    }
+    const datePart = stem.slice(0, 10);
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(datePart)) {
+        return false;
+    }
+    if (stem[10] !== "-") {
+        return false;
+    }
+    const slug = stem.slice(11);
+    if (!slug) {
+        return false;
+    }
+    let i = 0;
+    while (i < slug.length) {
+        let j = i;
+        while (j < slug.length) {
+            const ch = slug[j] ?? "";
+            const ok = (ch >= "a" && ch <= "z") || (ch >= "0" && ch <= "9");
+            if (!ok) {
+                break;
+            }
+            j += 1;
+        }
+        if (j === i) {
+            return false;
+        }
+        i = j;
+        if (i < slug.length) {
+            if (slug[i] !== "-") {
+                return false;
+            }
+            i += 1;
+            if (i >= slug.length) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/** Check filename matches YYYY-MM-DD-descriptive-slug.vbrief.json (D7). */
+export function validateFilename(filepath) {
+    const name = filepath.split("/").pop() ?? filepath;
+    if (name === "PROJECT-DEFINITION.vbrief.json") {
+        return [];
+    }
+    if (!matchesFilenameConvention(name)) {
+        return [
+            `${filepath}: filename '${name}' does not match convention ` +
+                "YYYY-MM-DD-descriptive-slug.vbrief.json (D7)",
+        ];
+    }
+    return [];
+}
+//# sourceMappingURL=filename.js.map

package/dist/vbrief-validate/folder-status.d.ts

@@ -0,0 +1,4 @@
+import type { JsonObject } from "./schema.js";
+/** Verify plan.status matches the lifecycle folder the file is in (D2). */
+export declare function validateFolderStatus(filepath: string, data: JsonObject, vbriefDir: string): string[];
+//# sourceMappingURL=folder-status.d.ts.map

package/dist/vbrief-validate/folder-status.js

@@ -0,0 +1,30 @@
+import { FOLDER_ALLOWED_STATUSES } from "./constants.js";
+import { lifecycleFolderFor } from "./paths.js";
+/** Verify plan.status matches the lifecycle folder the file is in (D2). */
+export function validateFolderStatus(filepath, data, vbriefDir) {
+    const folder = lifecycleFolderFor(filepath, vbriefDir);
+    if (folder === null || !(folder in FOLDER_ALLOWED_STATUSES)) {
+        return [];
+    }
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return [];
+    }
+    const status = plan.status;
+    if (status === undefined || status === null) {
+        return [];
+    }
+    const allowed = FOLDER_ALLOWED_STATUSES[folder];
+    if (allowed === undefined || !allowed.has(String(status))) {
+        const sorted = [...(allowed ?? [])]
+            .sort()
+            .map((s) => `'${s}'`)
+            .join(", ");
+        return [
+            `${filepath}: plan.status is '${String(status)}' but file is in ` +
+                `'${folder}/' (allowed statuses: [${sorted}]) (D2)`,
+        ];
+    }
+    return [];
+}
+//# sourceMappingURL=folder-status.js.map

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

@@ -0,0 +1,14 @@
+export type { ConformanceEvaluateResult, ConformanceFinding, ConformanceMode, } from "./conformance.js";
+export { ALLOW_LIST, DOC_CORE, evaluateConformance, ITEM_CORE, PLAN_CORE, renderFinding, scanVbrief, } from "./conformance.js";
+export { LIFECYCLE_FOLDERS, USAGE, VALID_STATUSES } from "./constants.js";
+export { matchesFilenameConvention, validateFilename } from "./filename.js";
+export { validateFolderStatus } from "./folder-status.js";
+export type { ConformanceCliOptions, ValidateCliOptions } from "./main.js";
+export { cmdVbriefValidate, runConformance, runValidate } from "./main.js";
+export { validateOriginProvenance } from "./origin.js";
+export { validateSessionRitualStalenessHoursOnPlan, validateTriageRankingLabelsOnPlan, validateWipCapOnPlan, } from "./plan-hooks.js";
+export { validateProjectDefinition } from "./project-definition.js";
+export { normalizeNarrativeKey, validateVbriefSchema } from "./schema.js";
+export type { ValidateAllResult } from "./validate-all.js";
+export { discoverVbriefs, validateAll, validateAllMigration, } from "./validate-all.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/vbrief-validate/index.js

@@ -0,0 +1,11 @@
+export { ALLOW_LIST, DOC_CORE, evaluateConformance, ITEM_CORE, PLAN_CORE, renderFinding, scanVbrief, } from "./conformance.js";
+export { LIFECYCLE_FOLDERS, USAGE, VALID_STATUSES } from "./constants.js";
+export { matchesFilenameConvention, validateFilename } from "./filename.js";
+export { validateFolderStatus } from "./folder-status.js";
+export { cmdVbriefValidate, runConformance, runValidate } from "./main.js";
+export { validateOriginProvenance } from "./origin.js";
+export { validateSessionRitualStalenessHoursOnPlan, validateTriageRankingLabelsOnPlan, validateWipCapOnPlan, } from "./plan-hooks.js";
+export { validateProjectDefinition } from "./project-definition.js";
+export { normalizeNarrativeKey, validateVbriefSchema } from "./schema.js";
+export { discoverVbriefs, validateAll, validateAllMigration, } from "./validate-all.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,17 @@
+export interface ValidateCliOptions {
+    readonly vbriefDir?: string;
+    readonly strictOriginTypes?: boolean;
+    readonly warningsAsErrors?: boolean;
+}
+export interface ConformanceCliOptions {
+    readonly mode?: "all" | "staged";
+    readonly projectRoot?: string;
+    readonly allowList?: string | null;
+    readonly quiet?: boolean;
+}
+/** CLI entry for vbrief_validate.py parity. */
+export declare function runValidate(argv: string[]): number;
+/** CLI entry for verify_vbrief_conformance.py parity. */
+export declare function runConformance(argv: string[]): number;
+export declare function cmdVbriefValidate(argv: string[]): number;
+//# sourceMappingURL=main.d.ts.map