@deftai/directive-core 0.58.0 → 0.60.0

package/dist/migrate-preflight/index.js

@@ -0,0 +1,193 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { defaultWhich } from "../scm/binary.js";
+import { detectPreCutoverLegacy, isCurrentGeneratedSpecification, isGeneratedSpecificationExport, missingLifecycleFolders, } from "../vbrief-validate/precutover.js";
+function resolveContentRoot(frameworkRoot) {
+    const nested = join(frameworkRoot, "content");
+    try {
+        if (statSync(nested).isDirectory())
+            return nested;
+    }
+    catch {
+        // consumer deposit: content lives directly under framework root
+    }
+    return frameworkRoot;
+}
+export function checkUv(which = defaultWhich) {
+    if (which("uv") !== null) {
+        return { name: "uv", status: "PASS", message: "uv is on PATH." };
+    }
+    return {
+        name: "uv",
+        status: "FAIL",
+        message: "uv is not on PATH. Install from https://docs.astral.sh/uv/ and re-run.",
+    };
+}
+export function checkLayout(deftRoot, projectRoot) {
+    const migrator = join(deftRoot, "scripts", "migrate_vbrief.py");
+    if (!existsSync(migrator) || !statSync(migrator).isFile()) {
+        return {
+            name: "layout",
+            status: "FAIL",
+            message: `Migrator script missing at ${migrator}. The framework checkout appears incomplete or pre-v0.20; refresh per deft/QUICK-START.md.`,
+        };
+    }
+    const schemasDir = join(resolveContentRoot(deftRoot), "vbrief", "schemas");
+    if (!existsSync(schemasDir) || !statSync(schemasDir).isDirectory()) {
+        return {
+            name: "layout",
+            status: "FAIL",
+            message: `Framework schemas dir missing at ${schemasDir}. Refresh the deft checkout (see deft/QUICK-START.md).`,
+        };
+    }
+    const projectVbrief = join(projectRoot, "vbrief");
+    if (!existsSync(projectVbrief)) {
+        return {
+            name: "layout",
+            status: "WARN",
+            message: `Project vbrief/ not present at ${projectVbrief} -- migrator will create it on first run; this is expected for greenfield projects.`,
+        };
+    }
+    return {
+        name: "layout",
+        status: "PASS",
+        message: `Framework migrator + schemas present; project vbrief/ at ${projectVbrief}.`,
+    };
+}
+export function checkGitClean(projectRoot) {
+    try {
+        const stdout = execFileSync("git", ["status", "--porcelain"], {
+            cwd: projectRoot,
+            encoding: "utf8",
+        });
+        if (stdout.trim()) {
+            return {
+                name: "git-clean",
+                status: "WARN",
+                message: "Working tree is dirty. The migrator will refuse to run without --force; preview with `task migrate:vbrief -- --dry-run` first.",
+            };
+        }
+        return { name: "git-clean", status: "PASS", message: "Working tree is clean." };
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+            return {
+                name: "git-clean",
+                status: "WARN",
+                message: "git executable not on PATH; skipping working-tree check. Migrator's dirty-tree guard will still fire if applicable.",
+            };
+        }
+        return {
+            name: "git-clean",
+            status: "WARN",
+            message: `Not a git repository at ${projectRoot}; skipping working-tree check.`,
+        };
+    }
+}
+export function checkDocumentModel(projectRoot) {
+    const legacy = detectPreCutoverLegacy(projectRoot);
+    if (legacy.length > 0) {
+        return {
+            name: "document-model",
+            status: "PASS",
+            message: `Legacy root artifact(s) detected: ${legacy.join(", ")}.`,
+        };
+    }
+    const specPath = join(projectRoot, "SPECIFICATION.md");
+    if (existsSync(specPath) && statSync(specPath).isFile()) {
+        let content = "";
+        try {
+            content = readFileSync(specPath, "utf8");
+        }
+        catch {
+            content = "";
+        }
+        if (isGeneratedSpecificationExport(projectRoot, content)) {
+            const missing = missingLifecycleFolders(projectRoot);
+            if (missing.length > 0) {
+                return {
+                    name: "document-model",
+                    status: "FAIL",
+                    message: `Generated SPECIFICATION.md detected (source: vbrief/specification.vbrief.json); repair missing lifecycle folder(s) instead of migrating: ${missing.join(", ")}.`,
+                };
+            }
+        }
+        if (isCurrentGeneratedSpecification(projectRoot, content)) {
+            return {
+                name: "document-model",
+                status: "FAIL",
+                message: "Current generated SPECIFICATION.md detected (source: vbrief/specification.vbrief.json); `task migrate:vbrief` is not needed.",
+            };
+        }
+    }
+    const vbriefRoot = join(projectRoot, "vbrief");
+    if (existsSync(vbriefRoot)) {
+        const missing = missingLifecycleFolders(projectRoot);
+        if (missing.length > 0) {
+            return {
+                name: "document-model",
+                status: "PASS",
+                message: `Partial vBRIEF layout detected; missing lifecycle folder(s): ${missing.join(", ")}.`,
+            };
+        }
+    }
+    return {
+        name: "document-model",
+        status: "WARN",
+        message: "No legacy root SPECIFICATION.md/PROJECT.md artifacts detected. Migration may have nothing to do.",
+    };
+}
+export function evaluate(deftRoot, projectRoot, which = defaultWhich) {
+    const results = [
+        checkUv(which),
+        checkLayout(deftRoot, projectRoot),
+        checkDocumentModel(projectRoot),
+        checkGitClean(projectRoot),
+    ];
+    if (results.some((r) => r.status === "FAIL")) {
+        return { exitCode: 1, results };
+    }
+    return { exitCode: 0, results };
+}
+export function formatCheckLine(result) {
+    return `CHECK ${result.name}: ${result.status} ${result.message}`;
+}
+export function runMigratePreflight(args) {
+    const projectRoot = resolve(args.projectRoot);
+    const deftRoot = resolve(args.deftRoot);
+    if (!existsSync(projectRoot) || !statSync(projectRoot).isDirectory()) {
+        return {
+            kind: "config",
+            message: `--project-root must be an existing directory: ${args.projectRoot}`,
+        };
+    }
+    if (!existsSync(deftRoot) || !statSync(deftRoot).isDirectory()) {
+        return {
+            kind: "config",
+            message: `--deft-root must be an existing directory: ${args.deftRoot}`,
+        };
+    }
+    const { exitCode, results } = evaluate(deftRoot, projectRoot);
+    return { kind: "ready", exitCode, results };
+}
+export function emitMigratePreflight(outcome, io, quiet) {
+    for (const result of outcome.results) {
+        if (quiet && result.status === "PASS")
+            continue;
+        const line = `${formatCheckLine(result)}\n`;
+        if (result.status === "FAIL")
+            io.writeErr(line);
+        else
+            io.writeOut(line);
+    }
+    if (outcome.exitCode === 1) {
+        io.writeErr("migrate:preflight FAILED -- resolve the FAIL line(s) above before running `task migrate:vbrief`.\n");
+    }
+    else {
+        io.writeOut("migrate:preflight OK -- environment ready for `task migrate:vbrief`.\n");
+    }
+    return outcome.exitCode;
+}
+//# sourceMappingURL=index.js.map

package/dist/release/index.d.ts

@@ -5,9 +5,10 @@ export * from "./git.js";
 export * from "./main.js";
 export * from "./paths.js";
 export * from "./pipeline.js";
+export * from "./preflight.js";
 export * from "./pyproject.js";
 export * from "./pyproject-sync.js";
-export * from "./python-bridge.js";
+export * from "./python-steps.js";
 export * from "./spawn.js";
 export * from "./types.js";
 export * from "./version.js";

package/dist/release/index.js

@@ -6,9 +6,10 @@ export * from "./git.js";
 export * from "./main.js";
 export * from "./paths.js";
 export * from "./pipeline.js";
+export * from "./preflight.js";
 export * from "./pyproject.js";
 export * from "./pyproject-sync.js";
-export * from "./python-bridge.js";
+export * from "./python-steps.js";
 export * from "./spawn.js";
 export * from "./types.js";
 export * from "./version.js";

package/dist/release/pipeline.js

@@ -5,8 +5,9 @@ import { EXIT_CONFIG_ERROR, EXIT_OK, EXIT_VIOLATION, RELEASE_ARTIFACTS, TOTAL_ST
 import { checkTagAvailable, createGithubRelease, readTextFile, verifyReleaseDraft } from "./gh.js";
 import { checkGitClean, commitReleaseArtifacts, createTag, currentBranch, pushRelease, releaseCommitSubject, } from "./git.js";
 import { resolveScriptsDir, todayIso } from "./paths.js";
+import { runReleaseCheck } from "./preflight.js";
 import { pyprojectPathFor, syncPyprojectForRelease } from "./pyproject-sync.js";
-import { checkVbriefLifecycleSync, refreshRoadmap, runBuild, runCi, runUvLock, } from "./python-bridge.js";
+import { checkVbriefLifecycleSync, refreshRoadmap, runBuild, runUvLock } from "./python-steps.js";
 import { isPrereleaseTag } from "./version.js";
 export function emit(step, label, status, target = process.stderr) {
     target.write(`[${step}/${TOTAL_STEPS}] ${label}... ${status}\n`);
@@ -20,7 +21,7 @@ export function runPipeline(config, seams = {}) {
     const readFile = seams.readFile ?? ((p) => readFileSync(p, "utf8"));
     const writeFile = seams.writeFile ?? ((p, c) => writeFileSync(p, c, "utf8"));
     const fileExists = seams.fileExists ?? ((p) => existsSync(p));
-    const runCiFn = seams.runCi ?? ((root) => runCi(root, scriptsDir, seams));
+    const runCiFn = seams.runCi ?? ((root) => runReleaseCheck(root));
     const refreshRoadmapFn = seams.refreshRoadmap ?? ((root) => refreshRoadmap(root, scriptsDir, seams));
     const checkVbriefFn = seams.checkVbriefLifecycleSync ??
         ((root, repo) => checkVbriefLifecycleSync(root, repo, scriptsDir, seams));
@@ -100,7 +101,11 @@ export function runPipeline(config, seams = {}) {
             return EXIT_VIOLATION;
         }
     }
-    // Step 5: CI.
+    // Step 5: CI pre-flight. The functional path now invokes the native
+    // TypeScript `task check` (via `runReleaseCheck`, #2022 Phase 1) instead of
+    // the ci_local.py bridge, but the emitted label/dry-run text is kept
+    // byte-identical to the Python oracle (scripts/release.py) so the #1729
+    // golden-diff release-parity gate stays green until the oracle is retired.
     label = "Pre-flight CI (task ci:local | fallback task check)";
     if (config.skipCi) {
         emit(5, label, "SKIP (--skip-ci)");

package/dist/release/preflight.d.ts

@@ -0,0 +1,27 @@
+/**
+ * preflight.ts -- Native TypeScript release Step-5 pre-flight (#2022 Phase 1).
+ *
+ * Promotes the context-aware `task check` orchestrator (check/orchestrator.ts)
+ * to the primary release pre-flight, replacing the removed `ci_local.py`
+ * python-bridge shim. The maintainer release runs in the framework-source
+ * context, so the framework root equals the project root and the orchestrator
+ * dispatches `check:framework-source`.
+ */
+import { type CheckOrchestratorSeams } from "../check/orchestrator.js";
+/** Seams for test isolation of the native release pre-flight. */
+export interface ReleasePreflightSeams {
+    /** Override the check dispatcher (default: dispatchTaskCheck from check/orchestrator). */
+    readonly dispatchCheck?: (frameworkRoot: string, projectRoot: string, seams?: CheckOrchestratorSeams) => number;
+    /** Seams forwarded to the underlying check orchestrator (e.g. taskBin, spawnFn). */
+    readonly checkSeams?: CheckOrchestratorSeams;
+}
+/**
+ * Run the native TypeScript `task check` as the release pre-flight.
+ *
+ * Returns the pipeline's standard `[ok, message]` tuple. The maintainer release
+ * cuts the framework itself, so we pass `projectRoot` as both the framework root
+ * and the project root -- the orchestrator then resolves the framework-source
+ * context and runs `check:framework-source`.
+ */
+export declare function runReleaseCheck(projectRoot: string, seams?: ReleasePreflightSeams): [boolean, string];
+//# sourceMappingURL=preflight.d.ts.map

package/dist/release/preflight.js

@@ -0,0 +1,27 @@
+/**
+ * preflight.ts -- Native TypeScript release Step-5 pre-flight (#2022 Phase 1).
+ *
+ * Promotes the context-aware `task check` orchestrator (check/orchestrator.ts)
+ * to the primary release pre-flight, replacing the removed `ci_local.py`
+ * python-bridge shim. The maintainer release runs in the framework-source
+ * context, so the framework root equals the project root and the orchestrator
+ * dispatches `check:framework-source`.
+ */
+import { dispatchTaskCheck } from "../check/orchestrator.js";
+/**
+ * Run the native TypeScript `task check` as the release pre-flight.
+ *
+ * Returns the pipeline's standard `[ok, message]` tuple. The maintainer release
+ * cuts the framework itself, so we pass `projectRoot` as both the framework root
+ * and the project root -- the orchestrator then resolves the framework-source
+ * context and runs `check:framework-source`.
+ */
+export function runReleaseCheck(projectRoot, seams = {}) {
+    const dispatch = seams.dispatchCheck ?? dispatchTaskCheck;
+    const code = dispatch(projectRoot, projectRoot, seams.checkSeams);
+    if (code === 0) {
+        return [true, "ran native TypeScript task check"];
+    }
+    return [false, `task check failed (exit ${code})`];
+}
+//# sourceMappingURL=preflight.js.map

package/dist/release/{python-bridge.d.ts → python-steps.d.ts}

@@ -1,7 +1,6 @@
 import type { ReleaseSeams } from "./types.js";
-export declare function runCi(projectRoot: string, scriptsDir: string, seams?: ReleaseSeams): [boolean, string];
 export declare function refreshRoadmap(projectRoot: string, scriptsDir: string, seams?: ReleaseSeams): [boolean, string];
 export declare function checkVbriefLifecycleSync(projectRoot: string, repo: string, scriptsDir: string, seams?: ReleaseSeams): [boolean, number, string];
 export declare function runBuild(projectRoot: string, scriptsDir: string, version: string | null, seams?: ReleaseSeams): [boolean, string];
 export declare function runUvLock(projectRoot: string, seams?: ReleaseSeams): [boolean, string];
-//# sourceMappingURL=python-bridge.d.ts.map
+//# sourceMappingURL=python-steps.d.ts.map

package/dist/release/{python-bridge.js → python-steps.js}

@@ -1,3 +1,15 @@
+/**
+ * python-steps.ts -- Residual Python-backed release pipeline steps.
+ *
+ * #2022 Phase 1 removed the `ci_local.py` Step-5 pre-flight bridge (now native
+ * TypeScript via release/preflight.ts), retiring the former `python-bridge.ts`
+ * module. These remaining steps still shell into bundled Python and stay here
+ * until their own purge phases land:
+ *   - refreshRoadmap (Step 7)            -> scripts/roadmap_render.py
+ *   - checkVbriefLifecycleSync (Step 3)  -> scripts/reconcile_issues.py
+ *   - runBuild (Step 8)                  -> scripts/build_dist.py (Bucket B, deleted by #1860)
+ *   - runUvLock (Step 6)                 -> `uv lock`
+ */
 import { existsSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { defaultWhich, spawnText } from "./spawn.js";
@@ -9,19 +21,6 @@ function runUvPython(_scriptsDir, code, cwd, env = process.env, seams = {}) {
         timeoutMs: 300_000,
     });
 }
-export function runCi(projectRoot, scriptsDir, seams = {}) {
-    const code = [
-        "import sys",
-        `sys.path.insert(0, ${JSON.stringify(scriptsDir)})`,
-        "import ci_local",
-        `sys.exit(ci_local.main(['--root', ${JSON.stringify(projectRoot)}]))`,
-    ].join("\n");
-    const result = runUvPython(scriptsDir, code, scriptsDir, process.env, seams);
-    if (result.status !== 0) {
-        return [false, `ci:local failed (exit ${result.status})`];
-    }
-    return [true, "ran ci:local"];
-}
 export function refreshRoadmap(projectRoot, scriptsDir, seams = {}) {
     const pending = join(projectRoot, "vbrief", "pending");
     const roadmap = join(projectRoot, "ROADMAP.md");
@@ -141,4 +140,4 @@ export function runUvLock(projectRoot, seams = {}) {
     }
     return [true, "uv.lock regenerated"];
 }
-//# sourceMappingURL=python-bridge.js.map
+//# sourceMappingURL=python-steps.js.map

package/dist/release-e2e/greenfield-python-free-smoke-cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=greenfield-python-free-smoke-cli.d.ts.map

package/dist/release-e2e/greenfield-python-free-smoke-cli.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { rehearseGreenfieldPythonFreeSmoke } from "./greenfield-python-free-smoke.js";
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "..");
+const skipWorkspacePrep = process.env.DEFT_GREENFIELD_SKIP_PREP === "1";
+const [ok, reason] = rehearseGreenfieldPythonFreeSmoke(repoRoot, {}, { skipWorkspacePrep });
+process.stdout.write(`${reason}\n`);
+process.exit(ok ? 0 : 1);
+//# sourceMappingURL=greenfield-python-free-smoke-cli.js.map

package/dist/release-e2e/greenfield-python-free-smoke.d.ts

@@ -0,0 +1,12 @@
+import type { E2ESeams } from "./types.js";
+export interface GreenfieldSmokeSeams extends E2ESeams {
+}
+export interface GreenfieldSmokeOptions {
+    skipWorkspacePrep?: boolean;
+}
+/**
+ * Greenfield npm smoke (#2022 Phase 3): pack/install directive, run init +
+ * task check in a Python-free PATH, and assert the deposit carries no Python.
+ */
+export declare function rehearseGreenfieldPythonFreeSmoke(repoRoot: string, seams?: GreenfieldSmokeSeams, options?: GreenfieldSmokeOptions): [boolean, string];
+//# sourceMappingURL=greenfield-python-free-smoke.d.ts.map

package/dist/release-e2e/greenfield-python-free-smoke.js

@@ -0,0 +1,183 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { collectPythonArtifacts, isRepoRootPythonRunShim } from "../deposit/python-free.js";
+import { defaultWhich, spawnText } from "../release/spawn.js";
+import { NPM_PUBLISH_PACKAGES } from "./constants.js";
+import { alignNpmPackageVersions, resolvePnpm } from "./npm-ops.js";
+const SMOKE_VERSION = "9.9.9-smoke";
+function pythonFreePathEnv(base = process.env) {
+    const pathKey = base.PATH !== undefined ? "PATH" : base.Path !== undefined ? "Path" : "PATH";
+    const current = base[pathKey] ?? "";
+    const filtered = current
+        .split(":")
+        .filter((entry) => !/(^|\/)python[0-9]*(?:\.\d+)?$/.test(entry))
+        .filter((entry) => !entry.includes("/pyenv/"))
+        .join(":");
+    return {
+        ...base,
+        [pathKey]: filtered,
+        DEFT_PYTHON: "",
+        PYTHON: "",
+    };
+}
+function seedMinimalProjectDefinition(projectDir) {
+    const vbriefDir = join(projectDir, "vbrief");
+    mkdirSync(vbriefDir, { recursive: true });
+    writeFileSync(join(vbriefDir, "PROJECT-DEFINITION.vbrief.json"), `${JSON.stringify({
+        vBRIEFInfo: { version: "0.6", description: "greenfield smoke fixture (#2022 Phase 3)" },
+        plan: {
+            title: "PROJECT-DEFINITION",
+            status: "running",
+            items: [],
+            policy: {},
+            narratives: {
+                Overview: "Greenfield smoke fixture (#2022 Phase 3).",
+                "tech stack": "Node.js",
+            },
+        },
+    }, null, 2)}\n`, "utf8");
+}
+function packTarballPath(packDir, pkgDir) {
+    const manifest = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf8"));
+    if (typeof manifest.name !== "string" || typeof manifest.version !== "string") {
+        return null;
+    }
+    const scoped = manifest.name.replaceAll("@", "").replaceAll("/", "-");
+    return join(packDir, `${scoped}-${manifest.version}.tgz`);
+}
+function runStep(spawn, label, cmd, args, options = {}) {
+    const result = spawn(cmd, args, options);
+    if (result.status !== 0) {
+        const detail = (result.stderr || result.stdout || "").trim();
+        return [false, `${label} failed (exit ${result.status}): ${detail.slice(-800)}`];
+    }
+    return [true, `${label} OK`];
+}
+/**
+ * Greenfield npm smoke (#2022 Phase 3): pack/install directive, run init +
+ * task check in a Python-free PATH, and assert the deposit carries no Python.
+ */
+export function rehearseGreenfieldPythonFreeSmoke(repoRoot, seams = {}, options = {}) {
+    const which = seams.which ?? seams.whichGh ?? defaultWhich;
+    const npm = which("npm");
+    if (!npm) {
+        return [true, "SKIP greenfield-python-free-smoke: npm not on PATH"];
+    }
+    const task = which("task");
+    if (!task) {
+        return [true, "SKIP greenfield-python-free-smoke: task (go-task) not on PATH"];
+    }
+    const pnpmPrefix = resolvePnpm(seams);
+    if (!pnpmPrefix || pnpmPrefix.length === 0) {
+        return [false, "greenfield-python-free-smoke FAIL: neither pnpm nor corepack on PATH"];
+    }
+    const [pnpmCmd, ...pnpmArgs] = pnpmPrefix;
+    if (pnpmCmd === undefined) {
+        return [false, "greenfield-python-free-smoke FAIL: pnpm command prefix is empty"];
+    }
+    const spawn = seams.spawnText ?? spawnText;
+    const work = mkdtempSync(join(tmpdir(), "deft-greenfield-smoke-"));
+    const packDir = join(work, "packs");
+    mkdirSync(packDir, { recursive: true });
+    const projectDir = join(work, "project");
+    const npmPrefix = join(work, "npm-prefix");
+    const envBase = { ...process.env, npm_config_prefix: npmPrefix };
+    const manifestBackup = new Map();
+    for (const pkg of NPM_PUBLISH_PACKAGES) {
+        const manifestPath = join(repoRoot, "packages", pkg, "package.json");
+        if (existsSync(manifestPath)) {
+            manifestBackup.set(manifestPath, readFileSync(manifestPath, "utf8"));
+        }
+    }
+    try {
+        let ok;
+        let reason;
+        if (!options.skipWorkspacePrep) {
+            [ok, reason] = runStep(spawn, "pnpm install", pnpmCmd, [...pnpmArgs, "install", "--frozen-lockfile"], {
+                cwd: repoRoot,
+                env: envBase,
+                timeoutMs: 120_000,
+            });
+            if (!ok)
+                return [false, `greenfield smoke: ${reason}`];
+            [ok, reason] = runStep(spawn, "pnpm build", pnpmCmd, [...pnpmArgs, "run", "build"], {
+                cwd: repoRoot,
+                env: envBase,
+                timeoutMs: 120_000,
+            });
+            if (!ok)
+                return [false, `greenfield smoke: ${reason}`];
+        }
+        [ok, reason] = alignNpmPackageVersions(repoRoot, SMOKE_VERSION);
+        if (!ok)
+            return [false, `greenfield smoke: ${reason}`];
+        const packed = [];
+        for (const pkg of NPM_PUBLISH_PACKAGES) {
+            const pkgDir = join(repoRoot, "packages", pkg);
+            [ok, reason] = runStep(spawn, `npm pack packages/${pkg}`, npm, ["pack", "--pack-destination", packDir], { cwd: pkgDir, env: envBase, timeoutMs: 120_000 });
+            if (!ok)
+                return [false, `greenfield smoke: ${reason}`];
+            const tgz = packTarballPath(packDir, pkgDir);
+            if (!tgz || !existsSync(tgz)) {
+                return [false, `greenfield smoke: missing pack tarball for ${pkg}`];
+            }
+            packed.push(tgz);
+        }
+        [ok, reason] = runStep(spawn, "npm install -g", npm, ["install", "-g", ...packed], {
+            env: envBase,
+            timeoutMs: 120_000,
+        });
+        if (!ok)
+            return [false, `greenfield smoke: ${reason}`];
+        const deft = join(npmPrefix, "bin", "deft");
+        if (!existsSync(deft)) {
+            return [false, `greenfield smoke: expected global deft at ${deft}`];
+        }
+        const pyFree = pythonFreePathEnv(envBase);
+        [ok, reason] = runStep(spawn, "directive init", deft, ["init", "--yes", "--repo-root", projectDir], {
+            cwd: work,
+            env: pyFree,
+            timeoutMs: 120_000,
+        });
+        if (!ok)
+            return [false, `greenfield smoke: ${reason}`];
+        seedMinimalProjectDefinition(projectDir);
+        const depositDir = join(projectDir, ".deft", "core");
+        const artifacts = collectPythonArtifacts(depositDir);
+        if (artifacts.length > 0) {
+            return [
+                false,
+                `greenfield smoke: deposit still contains Python artifacts: ${artifacts.map((a) => a.path).join(", ")}`,
+            ];
+        }
+        if (isRepoRootPythonRunShim(projectDir)) {
+            return [false, "greenfield smoke: repo-root Python run shim present after init"];
+        }
+        const checkEnv = {
+            ...pyFree,
+            PATH: `${join(npmPrefix, "bin")}:${pyFree.PATH ?? ""}`,
+            DEFT_SESSION_RITUAL_SKIP: "1",
+        };
+        [ok, reason] = runStep(spawn, "task deft:check", task, ["deft:check"], {
+            cwd: projectDir,
+            env: checkEnv,
+            timeoutMs: 180_000,
+        });
+        if (!ok)
+            return [false, `greenfield smoke: ${reason}`];
+        return [
+            true,
+            "greenfield-python-free-smoke: directive init + task deft:check passed with Python absent from PATH",
+        ];
+    }
+    finally {
+        for (const [manifestPath, contents] of manifestBackup) {
+            writeFileSync(manifestPath, contents, "utf8");
+        }
+        if (process.env.DEFT_GREENFIELD_KEEP_WORK !== "1") {
+            rmSync(work, { recursive: true, force: true });
+        }
+    }
+}
+//# sourceMappingURL=greenfield-python-free-smoke.js.map

package/dist/render/index.d.ts

@@ -4,7 +4,7 @@ export { availableCommands, cmdCoreValidate, formatFrameworkCommand, hasCommand,
 export * as prdRender from "./prd-render.js";
 export { main as prdRenderMain, parsePrdArgv, renderPrd } from "./prd-render.js";
 export * as projectRender from "./project-render.js";
-export { flagStaleNarratives, main as projectRenderMain, renderProjectDefinition, scanLifecycleFolders, } from "./project-render.js";
+export { acknowledgeProjectDefinitionStaleness, buildStalenessAcknowledgement, computeStalenessFlags, flagStaleNarratives, main as projectRenderMain, parseStalenessReview, renderProjectDefinition, scanLifecycleFolders, unacknowledgedCompletedItems, } from "./project-render.js";
 export * as roadmapRender from "./roadmap-render.js";
 export { checkDrift, generateRoadmapContent, main as roadmapRenderMain, renderRoadmap, renderRoadmapToBuffer, } from "./roadmap-render.js";
 export * as specRender from "./spec-render.js";

package/dist/render/index.js

@@ -4,7 +4,7 @@ export { availableCommands, cmdCoreValidate, formatFrameworkCommand, hasCommand,
 export * as prdRender from "./prd-render.js";
 export { main as prdRenderMain, parsePrdArgv, renderPrd } from "./prd-render.js";
 export * as projectRender from "./project-render.js";
-export { flagStaleNarratives, main as projectRenderMain, renderProjectDefinition, scanLifecycleFolders, } from "./project-render.js";
+export { acknowledgeProjectDefinitionStaleness, buildStalenessAcknowledgement, computeStalenessFlags, flagStaleNarratives, main as projectRenderMain, parseStalenessReview, renderProjectDefinition, scanLifecycleFolders, unacknowledgedCompletedItems, } from "./project-render.js";
 export * as roadmapRender from "./roadmap-render.js";
 export { checkDrift, generateRoadmapContent, main as roadmapRenderMain, renderRoadmap, renderRoadmapToBuffer, } from "./roadmap-render.js";
 export * as specRender from "./spec-render.js";

package/dist/render/project-render.d.ts

@@ -1,4 +1,11 @@
 type JsonObject = Record<string, unknown>;
+/** Durable review state for PROJECT-DEFINITION narrative staleness (#640). */
+export interface StalenessReviewMetadata {
+    /** ISO-8601 UTC when narratives were last reviewed/acknowledged. */
+    acknowledged_at: string;
+    /** Completed scope IDs incorporated at acknowledgement time (watermark). */
+    acknowledged_completed_scope_ids: readonly string[];
+}
 export interface LifecycleItem {
     id: string;
     title: string;
@@ -7,6 +14,16 @@ export interface LifecycleItem {
 }
 export declare function scanLifecycleFolders(vbriefDir: string): LifecycleItem[];
 export declare function flagStaleNarratives(narratives: Record<string, string>, completedItems: LifecycleItem[]): string[];
+/** Parse `plan.metadata.staleness_review` when present and well-formed. */
+export declare function parseStalenessReview(metadata: unknown): StalenessReviewMetadata | null;
+/** Completed scopes not yet covered by the acknowledgement watermark. */
+export declare function unacknowledgedCompletedItems(completedItems: readonly LifecycleItem[], review: StalenessReviewMetadata | null): LifecycleItem[];
+/** Build acknowledgement metadata for the current completed-scope set. */
+export declare function buildStalenessAcknowledgement(completedItems: readonly LifecycleItem[], options?: {
+    now?: Date;
+    existing?: StalenessReviewMetadata | null;
+}): StalenessReviewMetadata;
+export declare function computeStalenessFlags(narratives: Record<string, string>, completedItems: readonly LifecycleItem[], review?: StalenessReviewMetadata | null): string[];
 export declare function createSkeleton(items: LifecycleItem[], now: string): JsonObject;
 export interface RenderProjectOptions {
     readonly now?: Date;
@@ -14,6 +31,13 @@ export interface RenderProjectOptions {
 export type RenderProjectResult = readonly [boolean, string];
 /** Regenerate PROJECT-DEFINITION.vbrief.json (mirrors ``scripts/project_render.render_project_definition``). */
 export declare function renderProjectDefinition(vbriefDir: string, options?: RenderProjectOptions): RenderProjectResult;
+/**
+ * Mark current completed scopes as reviewed for PROJECT-DEFINITION narratives.
+ *
+ * Distinct from `task reconcile:issues`, which reconciles origin freshness on scope
+ * vBRIEFs — this path only clears narrative staleness heuristics on render.
+ */
+export declare function acknowledgeProjectDefinitionStaleness(vbriefDir: string, options?: RenderProjectOptions): RenderProjectResult;
 /** CLI entry (mirrors ``scripts/project_render.main``). */
 export declare function main(argv: readonly string[]): number;
 export {};