@deftai/directive-core 0.59.0 → 0.61.0

package/dist/spec-authority/migration-fidelity.js

@@ -0,0 +1,96 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { PRODUCT_NARRATIVE_KEYS } from "./constants.js";
+const LIFECYCLE_SCAN = ["proposed", "pending", "active", "completed", "cancelled"];
+function loadJson(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function planNarrativeKeys(doc) {
+    const keys = new Set();
+    const plan = doc.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan))
+        return keys;
+    const narratives = plan.narratives;
+    if (typeof narratives !== "object" || narratives === null || Array.isArray(narratives))
+        return keys;
+    for (const [key, val] of Object.entries(narratives)) {
+        if (typeof val === "string" && val.trim())
+            keys.add(key.toLowerCase());
+    }
+    return keys;
+}
+function collectCanonicalNarrativeKeys(vbriefDir) {
+    const keys = new Set();
+    const pdPath = join(vbriefDir, "PROJECT-DEFINITION.vbrief.json");
+    const pd = loadJson(pdPath);
+    if (pd) {
+        for (const k of planNarrativeKeys(pd))
+            keys.add(k);
+    }
+    for (const folder of LIFECYCLE_SCAN) {
+        const dir = join(vbriefDir, folder);
+        if (!existsSync(dir))
+            continue;
+        let names;
+        try {
+            names = readdirSync(dir).filter((n) => n.endsWith(".vbrief.json"));
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            const doc = loadJson(join(dir, name));
+            if (doc) {
+                for (const k of planNarrativeKeys(doc))
+                    keys.add(k);
+            }
+        }
+    }
+    return keys;
+}
+function premigrateNarrativeKeys(vbriefDir) {
+    const keys = new Set();
+    const premigrate = join(vbriefDir, "specification.premigrate.vbrief.json");
+    const doc = loadJson(premigrate);
+    if (!doc)
+        return keys;
+    for (const k of planNarrativeKeys(doc))
+        keys.add(k);
+    return keys;
+}
+function isProductKey(keyLower) {
+    if (keyLower === "overview")
+        return false;
+    return PRODUCT_NARRATIVE_KEYS.some((p) => p.toLowerCase() === keyLower);
+}
+/**
+ * #2005 migration-fidelity: when specification.vbrief.json is absent but a
+ * premigrate snapshot exists, require product narratives to land in PD or scopes.
+ */
+export function checkSpecMigrationFidelity(projectRoot) {
+    const vbriefDir = join(projectRoot, "vbrief");
+    const specPath = join(vbriefDir, "specification.vbrief.json");
+    if (existsSync(specPath))
+        return [];
+    const premigratePath = join(vbriefDir, "specification.premigrate.vbrief.json");
+    if (!existsSync(premigratePath))
+        return [];
+    const premigrateKeys = premigrateNarrativeKeys(vbriefDir);
+    const productPremigrate = [...premigrateKeys].filter(isProductKey);
+    if (productPremigrate.length === 0)
+        return [];
+    const canonicalKeys = collectCanonicalNarrativeKeys(vbriefDir);
+    const missing = productPremigrate.filter((k) => !canonicalKeys.has(k));
+    if (missing.length === 0)
+        return [];
+    return [
+        `vbrief/specification.vbrief.json is absent but vbrief/specification.premigrate.vbrief.json retains product narratives not found in PROJECT-DEFINITION or lifecycle scope vBRIEFs: ${missing.join(", ")}. ` +
+            "Do not delete the legacy spec without migrating content. Run `task migrate:vbrief` or manually merge narratives into PROJECT-DEFINITION / scope vBRIEFs before removing the premigrate snapshot. See #2005.",
+    ];
+}
+//# sourceMappingURL=migration-fidelity.js.map

package/dist/spec-authority/narratives.d.ts

@@ -0,0 +1,6 @@
+import type { ResolvedSpecAuthority } from "./resolver.js";
+/** Merge product narratives per Wave 0 locked precedence. */
+export declare function resolveExportNarratives(authority: ResolvedSpecAuthority): Record<string, string>;
+export declare function renderNarrativeSections(narratives: Record<string, string>): string[];
+export declare function greenfieldOverviewNonEmpty(authority: ResolvedSpecAuthority): boolean;
+//# sourceMappingURL=narratives.d.ts.map

package/dist/spec-authority/narratives.js

@@ -0,0 +1,84 @@
+import { readFileSync } from "node:fs";
+import { SPECIFICATION_NARRATIVE_KEY_ORDER } from "../render/constants.js";
+import { STAKEHOLDER_EXCLUDED_NARRATIVE_KEYS } from "./constants.js";
+function loadJson(path) {
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+function planNarratives(doc) {
+    const plan = doc.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan))
+        return {};
+    const narratives = plan.narratives;
+    if (typeof narratives !== "object" || narratives === null || Array.isArray(narratives))
+        return {};
+    const out = {};
+    for (const [key, val] of Object.entries(narratives)) {
+        if (typeof val === "string")
+            out[key] = val;
+    }
+    return out;
+}
+function isExcludedNarrativeKey(key) {
+    return STAKEHOLDER_EXCLUDED_NARRATIVE_KEYS.has(key.toLowerCase().replace(/\s+/g, ""));
+}
+/** Merge product narratives per Wave 0 locked precedence. */
+export function resolveExportNarratives(authority) {
+    const pd = loadJson(authority.projectDefPath);
+    const pdNarratives = planNarratives(pd);
+    if (authority.kind === "greenfield") {
+        const filtered = {};
+        for (const [key, val] of Object.entries(pdNarratives)) {
+            if (!isExcludedNarrativeKey(key) && val.trim())
+                filtered[key] = val;
+        }
+        return filtered;
+    }
+    const specPath = authority.specPath;
+    if (!specPath)
+        return pdNarratives;
+    const spec = loadJson(specPath);
+    const specNarratives = planNarratives(spec);
+    const merged = {};
+    for (const [key, val] of Object.entries(specNarratives)) {
+        if (!isExcludedNarrativeKey(key) && val.trim())
+            merged[key] = val;
+    }
+    // PD identity additive when missing from spec.
+    const identityHints = ["overview", "architecture", "risksandunknowns", "risks", "unknowns"];
+    for (const [key, val] of Object.entries(pdNarratives)) {
+        if (!val.trim() || isExcludedNarrativeKey(key))
+            continue;
+        const lower = key.toLowerCase().replace(/\s+/g, "");
+        const isIdentity = identityHints.some((h) => lower.includes(h)) || lower === "overview";
+        if (!isIdentity)
+            continue;
+        const specHasKey = Object.keys(merged).some((k) => k.toLowerCase() === lower);
+        if (!specHasKey)
+            merged[key] = val;
+    }
+    return merged;
+}
+export function renderNarrativeSections(narratives) {
+    const lines = [];
+    const rendered = new Set();
+    for (const key of SPECIFICATION_NARRATIVE_KEY_ORDER) {
+        const val = narratives[key];
+        if (val?.trim()) {
+            lines.push(`## ${key}\n`, `${val}\n`);
+            rendered.add(key);
+        }
+    }
+    for (const key of Object.keys(narratives).sort()) {
+        if (rendered.has(key) || !narratives[key]?.trim())
+            continue;
+        lines.push(`## ${key}\n`, `${narratives[key]}\n`);
+    }
+    return lines;
+}
+export function greenfieldOverviewNonEmpty(authority) {
+    const pd = loadJson(authority.projectDefPath);
+    const narratives = planNarratives(pd);
+    const overview = Object.entries(narratives).find(([k]) => k.toLowerCase() === "overview");
+    return overview !== undefined && overview[1].trim().length > 0;
+}
+//# sourceMappingURL=narratives.js.map

package/dist/spec-authority/resolver.d.ts

@@ -0,0 +1,15 @@
+export type SpecAuthorityKind = "full-spec" | "greenfield";
+export interface ResolvedSpecAuthority {
+    readonly kind: SpecAuthorityKind;
+    readonly projectRoot: string;
+    readonly vbriefDir: string;
+    readonly projectDefPath: string;
+    readonly specPath: string | null;
+    readonly banner: string;
+}
+export declare function resolveSpecAuthority(projectRoot: string): ResolvedSpecAuthority | null;
+export declare function readSpecMarkdown(projectRoot: string): string;
+export declare function isFullSpecState(projectRoot: string): boolean;
+export declare function isGreenfieldSpecExport(projectRoot: string): boolean;
+export declare function isCurrentGeneratedSpecification(projectRoot: string): boolean;
+//# sourceMappingURL=resolver.d.ts.map

package/dist/spec-authority/resolver.js

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { SPEC_RENDER_BANNER } from "../render/constants.js";
+import { EXPORT_SPEC_PD_BANNER, GENERATED_SPEC_PURPOSE, GENERATED_SPEC_SOURCE_PD, GENERATED_SPEC_SOURCE_SPEC, } from "./constants.js";
+const SPEC_REL = join("vbrief", "specification.vbrief.json");
+const PD_REL = join("vbrief", "PROJECT-DEFINITION.vbrief.json");
+export function resolveSpecAuthority(projectRoot) {
+    const root = projectRoot;
+    const vbriefDir = join(root, "vbrief");
+    const projectDefPath = join(root, PD_REL);
+    if (!existsSync(projectDefPath))
+        return null;
+    const specPath = join(root, SPEC_REL);
+    const hasSpec = existsSync(specPath);
+    const kind = hasSpec ? "full-spec" : "greenfield";
+    const banner = kind === "full-spec" ? SPEC_RENDER_BANNER : EXPORT_SPEC_PD_BANNER;
+    return {
+        kind,
+        projectRoot: root,
+        vbriefDir,
+        projectDefPath,
+        specPath: hasSpec ? specPath : null,
+        banner,
+    };
+}
+export function readSpecMarkdown(projectRoot) {
+    const path = join(projectRoot, "SPECIFICATION.md");
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+export function isFullSpecState(projectRoot) {
+    const authority = resolveSpecAuthority(projectRoot);
+    if (authority?.kind !== "full-spec")
+        return false;
+    const specMd = readSpecMarkdown(projectRoot);
+    return specMd.includes(GENERATED_SPEC_PURPOSE) && specMd.includes(GENERATED_SPEC_SOURCE_SPEC);
+}
+export function isGreenfieldSpecExport(projectRoot) {
+    const authority = resolveSpecAuthority(projectRoot);
+    if (authority?.kind !== "greenfield")
+        return false;
+    const specMd = readSpecMarkdown(projectRoot);
+    return specMd.includes(GENERATED_SPEC_PURPOSE) && specMd.includes(GENERATED_SPEC_SOURCE_PD);
+}
+export function isCurrentGeneratedSpecification(projectRoot) {
+    return isFullSpecState(projectRoot) || isGreenfieldSpecExport(projectRoot);
+}
+//# sourceMappingURL=resolver.js.map

package/dist/task-surface/index.d.ts

@@ -0,0 +1,13 @@
+export interface TaskSurfaceIo {
+    writeOut: (text: string) => void;
+    writeErr: (text: string) => void;
+}
+/** Port of ``task change:changelog:check`` inline Python (#2022 Phase 2). */
+export declare function runChangelogCheck(projectRoot: string, io: TaskSurfaceIo): number;
+/** Port of ``task change:init`` inline Python (#2022 Phase 2). */
+export declare function runChangeInit(projectRoot: string, name: string, io: TaskSurfaceIo): number;
+/** Port of ``task commit:lint`` inline Python (#2022 Phase 2). */
+export declare function runCommitLint(projectRoot: string, io: TaskSurfaceIo): number;
+/** Port of ``task install:uninstall`` inline Python (#2022 Phase 2). */
+export declare function runInstallUninstall(projectRoot: string, io: TaskSurfaceIo): number;
+//# sourceMappingURL=index.d.ts.map

package/dist/task-surface/index.js

@@ -0,0 +1,126 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+const UNRELEASED_RE = /## \[Unreleased\][ \t]*\n([\s\S]*?)(?=\n## \[|$)/;
+const CHANGE_NAME_RE = /^[\w][\w-]*$/;
+const COMMIT_TYPES = "feat|fix|docs|chore|refactor|test|style|perf|ci|build|revert";
+const COMMIT_SUBJECT_RE = new RegExp(`^(${COMMIT_TYPES})(\\(.+\\))?!?: .+`);
+function proposalTemplate(name) {
+    return {
+        vBRIEFInfo: { version: "0.5" },
+        plan: {
+            title: name,
+            status: "draft",
+            narratives: {
+                Problem: "What is wrong or missing.",
+                Change: "What this proposal does about it.",
+                Scope: "In scope: ...  Out of scope: ...",
+                Impact: "What existing code/specs are affected.",
+                Risks: "What could go wrong.",
+                Approach: "How to implement the change.",
+                Alternatives: "What else was considered and why not.",
+                Dependencies: "What must exist before this works.",
+            },
+        },
+    };
+}
+function tasksTemplate(name) {
+    return {
+        vBRIEFInfo: { version: "0.5" },
+        plan: { title: name, status: "draft", items: [], edges: [] },
+    };
+}
+/** Port of ``task change:changelog:check`` inline Python (#2022 Phase 2). */
+export function runChangelogCheck(projectRoot, io) {
+    const path = join(resolve(projectRoot), "CHANGELOG.md");
+    if (!existsSync(path) || !statSync(path).isFile()) {
+        io.writeOut("FAIL: CHANGELOG.md not found\n");
+        return 1;
+    }
+    const text = readFileSync(path, "utf8");
+    const match = UNRELEASED_RE.exec(text);
+    if (match === null) {
+        io.writeOut("FAIL: No [Unreleased] section found in CHANGELOG.md\n");
+        return 1;
+    }
+    const body = match[1] ?? "";
+    const entries = body.split("\n").filter((line) => line.trimStart().startsWith("- "));
+    if (entries.length === 0) {
+        io.writeOut('FAIL: [Unreleased] section has no entries (no lines starting with "- ")\n');
+        return 1;
+    }
+    io.writeOut(`OK: CHANGELOG.md [Unreleased] section has ${entries.length} entries\n`);
+    return 0;
+}
+/** Port of ``task change:init`` inline Python (#2022 Phase 2). */
+export function runChangeInit(projectRoot, name, io) {
+    const trimmed = name.trim();
+    if (trimmed.length === 0) {
+        io.writeOut("FAIL: Usage: task change:init -- <name>\n");
+        return 1;
+    }
+    if (!CHANGE_NAME_RE.test(trimmed)) {
+        io.writeOut("FAIL: Name must contain only alphanumeric characters, underscores, and hyphens\n");
+        return 1;
+    }
+    const base = join(resolve(projectRoot), "history", "changes", trimmed);
+    if (existsSync(base)) {
+        io.writeOut(`FAIL: ${base} already exists\n`);
+        return 1;
+    }
+    mkdirSync(join(base, "specs"), { recursive: true });
+    writeFileSync(join(base, "proposal.vbrief.json"), `${JSON.stringify(proposalTemplate(trimmed), null, 2)}\n`, "utf8");
+    writeFileSync(join(base, "tasks.vbrief.json"), `${JSON.stringify(tasksTemplate(trimmed), null, 2)}\n`, "utf8");
+    io.writeOut(`OK: Created change proposal at ${base}/\n`);
+    for (const file of ["proposal.vbrief.json", "tasks.vbrief.json", "specs/"]) {
+        io.writeOut(`  - ${file}\n`);
+    }
+    return 0;
+}
+/** Port of ``task commit:lint`` inline Python (#2022 Phase 2). */
+export function runCommitLint(projectRoot, io) {
+    let stdout;
+    try {
+        stdout = execFileSync("git", ["log", "--format=%B", "-1"], {
+            cwd: resolve(projectRoot),
+            encoding: "utf8",
+        });
+    }
+    catch {
+        io.writeOut("FAIL: Could not read HEAD commit message\n");
+        return 1;
+    }
+    const msg = stdout.trim();
+    const subject = msg.split("\n")[0] ?? "";
+    if (!COMMIT_SUBJECT_RE.test(subject)) {
+        io.writeOut("FAIL: Commit message does not match conventional commit format\n");
+        io.writeOut(`  Got:      ${subject}\n`);
+        io.writeOut("  Expected: type(scope): description\n");
+        io.writeOut("  Types:    feat, fix, docs, chore, refactor, test, style, perf, ci, build, revert\n");
+        return 1;
+    }
+    io.writeOut("OK: Commit message is valid conventional commit\n");
+    io.writeOut(`  Subject: ${subject}\n`);
+    return 0;
+}
+/** Port of ``task install:uninstall`` inline Python (#2022 Phase 2). */
+export function runInstallUninstall(projectRoot, io) {
+    const path = join(resolve(projectRoot), "AGENTS.md");
+    if (!existsSync(path) || !statSync(path).isFile()) {
+        io.writeOut("No deft entry found in AGENTS.md\n");
+        return 0;
+    }
+    const original = readFileSync(path, "utf8");
+    const lines = original.split(/(?<=\n)/);
+    const filtered = lines.filter((line) => !line.startsWith("See deft/main.md") && !line.startsWith("Skills: deft/skills/"));
+    const next = filtered.join("");
+    if (next !== original) {
+        writeFileSync(path, next, "utf8");
+        io.writeOut("Removed deft entry from AGENTS.md\n");
+    }
+    else {
+        io.writeOut("No deft entry found in AGENTS.md\n");
+    }
+    return 0;
+}
+//# sourceMappingURL=index.js.map

package/dist/validate-content/validate-strategy-output.js

@@ -1,17 +1,9 @@
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readdirSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { checkSpecMigrationFidelity } from "../spec-authority/migration-fidelity.js";
+import { isFullSpecState } from "../spec-authority/resolver.js";
 import { isDatePrefixedVbriefFilename } from "./filename.js";
-const GENERATED_SPEC_PURPOSE = "<!-- Purpose: rendered specification -->";
-const GENERATED_SPEC_SOURCE = "<!-- Source of truth: vbrief/specification.vbrief.json -->";
 const LIFECYCLE_DIRS = ["proposed", "pending", "active", "completed", "cancelled"];
-function readTextSafe(path) {
-    try {
-        return readFileSync(path, "utf8");
-    }
-    catch {
-        return "";
-    }
-}
 function isDirSafe(path) {
     try {
         return statSync(path).isDirectory();
@@ -30,20 +22,6 @@ function isDeftFrameworkRoot(projectRoot) {
         (isDirSafe(join(projectRoot, "content", "strategies")) ||
             isDirSafe(join(projectRoot, "strategies"))));
 }
-function hasCompleteLifecycle(vbriefDir) {
-    return LIFECYCLE_DIRS.every((folder) => {
-        const p = join(vbriefDir, folder);
-        return existsSync(p) && statSync(p).isDirectory();
-    });
-}
-function isPostCutoverFullSpecState(projectRoot) {
-    const vbriefDir = join(projectRoot, "vbrief");
-    const specMd = readTextSafe(join(projectRoot, "SPECIFICATION.md"));
-    return (existsSync(join(vbriefDir, "PROJECT-DEFINITION.vbrief.json")) &&
-        hasCompleteLifecycle(vbriefDir) &&
-        specMd.includes(GENERATED_SPEC_PURPOSE) &&
-        specMd.includes(GENERATED_SPEC_SOURCE));
-}
 /** Pure validator returning error strings (empty == pass). */
 export function validateStrategyOutput(projectRoot, strict = false) {
     const root = resolve(projectRoot);
@@ -63,7 +41,7 @@ export function validateStrategyOutput(projectRoot, strict = false) {
             "(see v0-20-contract.md and task project:render).");
     }
     const specLegacy = join(vbriefDir, "specification.vbrief.json");
-    if (existsSync(specLegacy) && !isDeftFrameworkRoot(root) && !isPostCutoverFullSpecState(root)) {
+    if (existsSync(specLegacy) && !isDeftFrameworkRoot(root) && !isFullSpecState(root)) {
         errors.push("Legacy artifact vbrief/specification.vbrief.json present. " +
             "v0.20 strategies MUST NOT dual-write the old specification.vbrief.json " +
             "alongside scope vBRIEFs in the lifecycle folders. " +
@@ -85,6 +63,7 @@ export function validateStrategyOutput(projectRoot, strict = false) {
             }
         }
     }
+    errors.push(...checkSpecMigrationFidelity(root));
     return errors;
 }
 const FAILURE_HEADER = "❌ Strategy output shape validation FAILED (v0.20 contract gate)";

package/dist/vbrief-validate/main.js

@@ -122,6 +122,11 @@ export function cmdVbriefValidate(argv) {
     if (argv[0] === "conformance") {
         return runConformance(argv.slice(1));
     }
+    if (argv.includes("--staged") ||
+        (argv.includes("--all") &&
+            !argv.some((a) => a === "--vbrief-dir" || a.startsWith("--vbrief-dir=")))) {
+        return runConformance(argv);
+    }
     return runValidate(argv);
 }
 //# sourceMappingURL=main.js.map

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

@@ -1,31 +1,21 @@
+import { isFullSpecState, isGreenfieldSpecExport } from "../spec-authority/resolver.js";
 import { DEPRECATION_SENTINEL } from "../vbrief-build/constants.js";
 export { DEPRECATION_SENTINEL as DEPRECATED_REDIRECT_SENTINEL };
+export declare function missingLifecycleFolders(projectRoot: string): string[];
 /** Return true when markdown content is a migration redirect stub. */
 export declare function isDeprecationRedirect(content: string): boolean;
-/** Return true for a fully current ``task spec:render`` root export. */
+/** Full-spec generated export (specification.vbrief.json source line). */
+export declare function isGeneratedSpecificationExport(projectRoot: string, content: string): boolean;
+/** Return true for a fully current generated spec export (full-spec or greenfield). */
 export declare function isCurrentGeneratedSpecification(projectRoot: string, content: string): boolean;
+/** Return root artifact filenames that are legacy pre-v0.20 inputs (#793 / migrate preflight). */
+export declare function detectPreCutoverLegacy(projectRoot: string): string[];
 /** Structured result of a pre-cutover (pre-v0.20 document model) probe. */
 export interface PrecutoverDetection {
-    /** True when any legacy pre-v0.20 artifact still needs migration. */
     preCutover: boolean;
-    /** Human-readable reasons; empty when the project is on the current model. */
     reasons: string[];
 }
-/**
- * Detect whether ``projectRoot`` still carries pre-v0.20 (pre-cutover) document-model
- * artifacts that need migration. Mirrors the AGENTS.md "Pre-Cutover Check" rule and the
- * legacy ``scripts/_precutover.py`` helper: a project is pre-cutover when any of the
- * following hold:
- *
- * - ``SPECIFICATION.md`` exists and is neither a deprecation redirect nor a current
- *   generated spec export;
- * - ``PROJECT.md`` exists and is not a deprecation redirect;
- * - ``vbrief/`` exists but is missing one or more lifecycle folders.
- */
 export declare function detectPreCutover(projectRoot: string): PrecutoverDetection;
-/**
- * Render the single-line pre-cutover status string surfaced by ``deft doctor``.
- * Flags the migration-needed state with reasons, or reports a clean current-model state.
- */
 export declare function renderPrecutoverLine(projectRoot: string): string;
+export { isFullSpecState, isGreenfieldSpecExport };
 //# sourceMappingURL=precutover.d.ts.map

package/dist/vbrief-validate/precutover.js

@@ -1,13 +1,13 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
+import { GENERATED_SPEC_PURPOSE, GENERATED_SPEC_SOURCE_SPEC } from "../spec-authority/constants.js";
+import { isFullSpecState, isGreenfieldSpecExport } from "../spec-authority/resolver.js";
 import { DEPRECATION_SENTINEL } from "../vbrief-build/constants.js";
 export { DEPRECATION_SENTINEL as DEPRECATED_REDIRECT_SENTINEL };
 const DEPRECATION_REDIRECT_PURPOSE = "<!-- Purpose: deprecation redirect -->";
-const GENERATED_SPEC_PURPOSE = "<!-- Purpose: rendered specification -->";
-const GENERATED_SPEC_SOURCE = "<!-- Source of truth: vbrief/specification.vbrief.json -->";
 const SPEC_SOURCE_RELPATH = join("vbrief", "specification.vbrief.json");
 const LIFECYCLE_FOLDERS = ["proposed", "pending", "active", "completed", "cancelled"];
-function missingLifecycleFolders(projectRoot) {
+export function missingLifecycleFolders(projectRoot) {
     const vbriefRoot = join(projectRoot, "vbrief");
     return LIFECYCLE_FOLDERS.filter((folder) => !existsSync(join(vbriefRoot, folder)));
 }
@@ -18,14 +18,19 @@ function hasCompleteLifecycle(projectRoot) {
 export function isDeprecationRedirect(content) {
     return content.includes(DEPRECATION_SENTINEL) || content.includes(DEPRECATION_REDIRECT_PURPOSE);
 }
-function isGeneratedSpecificationExport(projectRoot, content) {
+/** Full-spec generated export (specification.vbrief.json source line). */
+export function isGeneratedSpecificationExport(projectRoot, content) {
     return (content.includes(GENERATED_SPEC_PURPOSE) &&
-        content.includes(GENERATED_SPEC_SOURCE) &&
+        content.includes(GENERATED_SPEC_SOURCE_SPEC) &&
         existsSync(join(projectRoot, SPEC_SOURCE_RELPATH)));
 }
-/** Return true for a fully current ``task spec:render`` root export. */
+/** Return true for a fully current generated spec export (full-spec or greenfield). */
 export function isCurrentGeneratedSpecification(projectRoot, content) {
-    return isGeneratedSpecificationExport(projectRoot, content) && hasCompleteLifecycle(projectRoot);
+    if (!hasCompleteLifecycle(projectRoot))
+        return false;
+    if (isGeneratedSpecificationExport(projectRoot, content))
+        return true;
+    return isGreenfieldSpecExport(projectRoot);
 }
 function isFile(path) {
     try {
@@ -43,17 +48,31 @@ function safeReadText(path) {
         return "";
     }
 }
-/**
- * Detect whether ``projectRoot`` still carries pre-v0.20 (pre-cutover) document-model
- * artifacts that need migration. Mirrors the AGENTS.md "Pre-Cutover Check" rule and the
- * legacy ``scripts/_precutover.py`` helper: a project is pre-cutover when any of the
- * following hold:
- *
- * - ``SPECIFICATION.md`` exists and is neither a deprecation redirect nor a current
- *   generated spec export;
- * - ``PROJECT.md`` exists and is not a deprecation redirect;
- * - ``vbrief/`` exists but is missing one or more lifecycle folders.
- */
+function rootMarkdownIsLegacy(projectRoot, filename, content) {
+    if (isDeprecationRedirect(content))
+        return false;
+    if (filename === "SPECIFICATION.md") {
+        if (isGeneratedSpecificationExport(projectRoot, content))
+            return false;
+        if (isGreenfieldSpecExport(projectRoot))
+            return false;
+    }
+    return filename === "SPECIFICATION.md" || filename === "PROJECT.md";
+}
+/** Return root artifact filenames that are legacy pre-v0.20 inputs (#793 / migrate preflight). */
+export function detectPreCutoverLegacy(projectRoot) {
+    const legacy = [];
+    for (const filename of ["SPECIFICATION.md", "PROJECT.md"]) {
+        const candidate = join(projectRoot, filename);
+        if (!isFile(candidate))
+            continue;
+        const content = safeReadText(candidate);
+        if (rootMarkdownIsLegacy(projectRoot, filename, content)) {
+            legacy.push(filename);
+        }
+    }
+    return legacy;
+}
 export function detectPreCutover(projectRoot) {
     const reasons = [];
     const specPath = join(projectRoot, "SPECIFICATION.md");
@@ -79,17 +98,14 @@ export function detectPreCutover(projectRoot) {
     }
     return { preCutover: reasons.length > 0, reasons };
 }
-/**
- * Render the single-line pre-cutover status string surfaced by ``deft doctor``.
- * Flags the migration-needed state with reasons, or reports a clean current-model state.
- */
 export function renderPrecutoverLine(projectRoot) {
     const { preCutover, reasons } = detectPreCutover(projectRoot);
     if (!preCutover) {
         return "Pre-cutover: none -- project is on the current vBRIEF document model.";
     }
-    // Collapse any embedded newlines so the status line stays a single line (CWE-116).
     const summary = reasons.join("; ").replace(/\r?\n/g, " ");
     return `Pre-cutover: migration needed -- ${summary}. Run \`deft migrate:vbrief\` to migrate.`;
 }
+// Re-export for classify callers (#2013).
+export { isFullSpecState, isGreenfieldSpecExport };
 //# sourceMappingURL=precutover.js.map

package/dist/verify-env/toolchain-check.d.ts

@@ -2,6 +2,10 @@ export interface ToolCheck {
     readonly name: string;
     readonly command: readonly string[];
 }
+export declare const MAINTAINER_TOOLS: readonly ToolCheck[];
+/** Consumer npm-deposit toolchain (#2022 Phase 3) -- no Python/go/uv maintainer tools. */
+export declare const CONSUMER_TOOLS: readonly ToolCheck[];
+/** @deprecated use MAINTAINER_TOOLS */
 export declare const TOOLS: readonly ToolCheck[];
 export type CommandRunner = (command: readonly string[], timeoutMs: number) => {
     returncode: number;
@@ -23,6 +27,9 @@ export declare function defaultCommandRunner(command: readonly string[], timeout
     error: "not-found" | "exception";
     message: string;
 };
-/** Run maintainer toolchain probe (mirrors scripts/toolchain-check.py). */
-export declare function runToolchainCheck(runner?: CommandRunner, tools?: readonly ToolCheck[]): ToolchainCheckResult;
+export interface ToolchainCheckOptions {
+    readonly consumer?: boolean;
+}
+/** Run maintainer or consumer toolchain probe (mirrors scripts/toolchain-check.py). */
+export declare function runToolchainCheck(runner?: CommandRunner, options?: ToolchainCheckOptions, tools?: readonly ToolCheck[]): ToolchainCheckResult;
 //# sourceMappingURL=toolchain-check.d.ts.map