@deftai/directive-core 0.62.0 → 0.64.0

package/dist/release/build-dist-runner.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=build-dist-runner.d.ts.map

package/dist/release/build-dist-runner.js

@@ -0,0 +1,21 @@
+/**
+ * Subprocess entry for sync callers (release pipeline, task build).
+ * Top-level await keeps the process alive until the archive is written.
+ */
+import { buildArchive, selectFormat } from "./build-dist.js";
+const version = process.argv[2];
+const root = process.argv[3];
+if (!version || !root) {
+    process.stderr.write("usage: build-dist-runner <version> <root>\n");
+    process.exit(2);
+}
+const fmt = selectFormat(process.env.DEFT_BUILD_FORMAT);
+try {
+    const out = await buildArchive(root, version, fmt);
+    process.stdout.write(`${out}\n`);
+}
+catch (err) {
+    process.stderr.write(`${String(err)}\n`);
+    process.exit(1);
+}
+//# sourceMappingURL=build-dist-runner.js.map

package/dist/release/build-dist.d.ts

@@ -0,0 +1,14 @@
+export declare const DEFAULT_EXCLUDES: Set<string>;
+export declare const DEFAULT_EXCLUDED_PATH_PREFIXES: readonly ["history/archive", "vbrief/completed", "vbrief/cancelled"];
+export declare const ARCHIVE_ROOT = "deft";
+export declare const CONTENT_PREFIX = "content/";
+export declare function iterSourceFiles(root: string, excludes?: ReadonlySet<string>, excludedPrefixes?: readonly string[]): Array<{
+    absPath: string;
+    archiveRel: string;
+}>;
+export declare function selectFormat(arg: string | null | undefined): "tar" | "zip";
+export declare function outputPath(root: string, version: string, fmt: "tar" | "zip"): string;
+export declare function buildArchive(root: string, version: string, fmt: "tar" | "zip", extraExcludes?: readonly string[]): Promise<string>;
+export declare function parseExtraExcludes(raw: string): string[];
+export declare function main(argv: readonly string[]): Promise<number>;
+//# sourceMappingURL=build-dist.d.ts.map

package/dist/release/build-dist.js

@@ -0,0 +1,171 @@
+import { createWriteStream, existsSync, mkdirSync, readdirSync, statSync, unlinkSync, } from "node:fs";
+import { createRequire } from "node:module";
+import { platform } from "node:os";
+import { dirname, join, relative, resolve } from "node:path";
+const { ZipArchive, TarArchive } = createRequire(import.meta.url)("archiver");
+export const DEFAULT_EXCLUDES = new Set([
+    ".git",
+    "dist",
+    "backup",
+    "node_modules",
+    "__pycache__",
+    ".venv",
+    "htmlcov",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".coverage",
+]);
+export const DEFAULT_EXCLUDED_PATH_PREFIXES = [
+    "history/archive",
+    "vbrief/completed",
+    "vbrief/cancelled",
+];
+export const ARCHIVE_ROOT = "deft";
+export const CONTENT_PREFIX = "content/";
+const VENDORED_TS_TEST_RE = /\.(test|spec)\.(c|m)?[jt]sx?$/i;
+function flattenContentPrefix(relPosix) {
+    if (relPosix === "content")
+        return relPosix;
+    if (relPosix.startsWith(CONTENT_PREFIX)) {
+        return relPosix.slice(CONTENT_PREFIX.length);
+    }
+    return relPosix;
+}
+function matchesExcludedPrefix(relPosix, prefixes) {
+    return prefixes.some((prefix) => relPosix === prefix || relPosix.startsWith(`${prefix}/`));
+}
+function isVendoredTsTest(relPosix) {
+    if (relPosix !== "packages" && !relPosix.startsWith("packages/")) {
+        return false;
+    }
+    const basename = relPosix.split("/").pop() ?? "";
+    return VENDORED_TS_TEST_RE.test(basename);
+}
+export function iterSourceFiles(root, excludes = DEFAULT_EXCLUDES, excludedPrefixes = DEFAULT_EXCLUDED_PATH_PREFIXES) {
+    const entries = [];
+    const walk = (dir) => {
+        let names;
+        try {
+            names = readdirSync(dir).sort();
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            if (excludes.has(name))
+                continue;
+            const absPath = join(dir, name);
+            let relPosix;
+            try {
+                relPosix = relative(root, absPath).split("\\").join("/");
+            }
+            catch {
+                continue;
+            }
+            if (matchesExcludedPrefix(relPosix, excludedPrefixes))
+                continue;
+            let st;
+            try {
+                st = statSync(absPath);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                walk(absPath);
+                continue;
+            }
+            if (!st.isFile())
+                continue;
+            if (isVendoredTsTest(relPosix))
+                continue;
+            entries.push({ absPath, archiveRel: flattenContentPrefix(relPosix) });
+        }
+    };
+    walk(root);
+    entries.sort((a, b) => a.archiveRel.localeCompare(b.archiveRel));
+    return entries;
+}
+export function selectFormat(arg) {
+    if (arg)
+        return arg.toLowerCase() === "zip" ? "zip" : "tar";
+    return platform().startsWith("win") ? "zip" : "tar";
+}
+export function outputPath(root, version, fmt) {
+    const suffix = fmt === "zip" ? "zip" : "tar.gz";
+    return join(root, "dist", `deft-${version}.${suffix}`);
+}
+export async function buildArchive(root, version, fmt, extraExcludes = []) {
+    const excludes = new Set([...DEFAULT_EXCLUDES, ...extraExcludes]);
+    const output = outputPath(root, version, fmt);
+    mkdirSync(dirname(output), { recursive: true });
+    if (existsSync(output)) {
+        unlinkSync(output);
+    }
+    const entries = iterSourceFiles(root, excludes);
+    await new Promise((resolvePromise, reject) => {
+        const out = createWriteStream(output);
+        const archive = fmt === "zip"
+            ? new ZipArchive({ zlib: { level: 9 } })
+            : new TarArchive({ gzip: true, gzipOptions: { level: 9 } });
+        out.on("close", () => resolvePromise());
+        out.on("error", (err) => reject(err));
+        archive.on("error", (err) => reject(err));
+        archive.pipe(out);
+        for (const { absPath, archiveRel } of entries) {
+            archive.file(absPath, { name: `${ARCHIVE_ROOT}/${archiveRel}` });
+        }
+        void archive.finalize();
+    });
+    return output;
+}
+export function parseExtraExcludes(raw) {
+    return raw
+        .split(",")
+        .map((p) => p.trim())
+        .filter(Boolean);
+}
+export async function main(argv) {
+    const args = [...argv];
+    let version = null;
+    let fmtArg = null;
+    let root = null;
+    let extra = "";
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--version")
+            version = args[++i];
+        else if (arg === "--format")
+            fmtArg = args[++i];
+        else if (arg === "--root")
+            root = args[++i];
+        else if (arg === "--exclude-extra")
+            extra = args[++i];
+        else if (arg === "-h" || arg === "--help") {
+            process.stderr.write("usage: build-dist --version X.Y.Z [--format tar|zip] [--root PATH] [--exclude-extra a,b]\n");
+            return 2;
+        }
+    }
+    if (!version) {
+        process.stderr.write("error: --version is required\n");
+        return 2;
+    }
+    const projectRoot = resolve(root ?? process.cwd());
+    if (!existsSync(projectRoot)) {
+        process.stderr.write(`error: root not found: ${projectRoot}\n`);
+        return 2;
+    }
+    const fmt = selectFormat(fmtArg);
+    try {
+        const out = await buildArchive(projectRoot, version, fmt, parseExtraExcludes(extra));
+        const printable = relative(projectRoot, out) || out;
+        process.stdout.write(`Created ${printable}\n`);
+        return 0;
+    }
+    catch (err) {
+        process.stderr.write(`error: ${String(err)}\n`);
+        return 1;
+    }
+}
+//# sourceMappingURL=build-dist.js.map

package/dist/release/constants.d.ts

@@ -13,7 +13,7 @@ export declare const FRESH_UNRELEASED_BLOCK: string;
 export declare const TOTAL_STEPS = 13;
 export declare const VERIFY_DRAFT_MAX_ATTEMPTS = 5;
 export declare const VERIFY_DRAFT_INTERVAL_SECONDS = 1;
-export declare const RELEASE_ARTIFACTS: readonly ["CHANGELOG.md", "ROADMAP.md", "pyproject.toml", "uv.lock"];
+export declare const RELEASE_ARTIFACTS: readonly ["CHANGELOG.md", "ROADMAP.md"];
 export declare const BRANCH_GATE_BYPASS_ENV = "DEFT_ALLOW_DEFAULT_BRANCH_COMMIT";
 export declare const DESTRUCTIVE_GH_GATE_BYPASS_ENV = "DEFT_ALLOW_DESTRUCTIVE_GH_VERBS";
 export declare const PYPROJECT_VERSION_LINE_RE: RegExp;

package/dist/release/constants.js

@@ -21,12 +21,7 @@ export const FRESH_UNRELEASED_BLOCK = "## [Unreleased]\n" +
 export const TOTAL_STEPS = 13;
 export const VERIFY_DRAFT_MAX_ATTEMPTS = 5;
 export const VERIFY_DRAFT_INTERVAL_SECONDS = 1.0;
-export const RELEASE_ARTIFACTS = [
-    "CHANGELOG.md",
-    "ROADMAP.md",
-    "pyproject.toml",
-    "uv.lock",
-];
+export const RELEASE_ARTIFACTS = ["CHANGELOG.md", "ROADMAP.md"];
 export const BRANCH_GATE_BYPASS_ENV = "DEFT_ALLOW_DEFAULT_BRANCH_COMMIT";
 export const DESTRUCTIVE_GH_GATE_BYPASS_ENV = "DEFT_ALLOW_DESTRUCTIVE_GH_VERBS";
 export const PYPROJECT_VERSION_LINE_RE = /version\s*=\s*"[^"]*"/;

package/dist/release/index.d.ts

@@ -1,14 +1,13 @@
+export * from "./build-dist.js";
 export * from "./constants.js";
 export * from "./flags.js";
 export * from "./gh.js";
 export * from "./git.js";
 export * from "./main.js";
+export * from "./native-steps.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-steps.js";
 export * from "./spawn.js";
 export * from "./types.js";
 export * from "./version.js";

package/dist/release/index.js

@@ -1,15 +1,14 @@
 /* v8 ignore file -- re-export barrel; covered via main.ts */
+export * from "./build-dist.js";
 export * from "./constants.js";
 export * from "./flags.js";
 export * from "./gh.js";
 export * from "./git.js";
 export * from "./main.js";
+export * from "./native-steps.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-steps.js";
 export * from "./spawn.js";
 export * from "./types.js";
 export * from "./version.js";

package/dist/release/native-steps.d.ts

@@ -0,0 +1,5 @@
+import type { ReleaseSeams } from "./types.js";
+export declare function refreshRoadmapNative(projectRoot: string): [boolean, string];
+export declare function checkVbriefLifecycleSyncNative(projectRoot: string, repo: string): [boolean, number, string];
+export declare function runBuildNative(projectRoot: string, version: string | null, _seams?: ReleaseSeams): [boolean, string];
+//# sourceMappingURL=native-steps.d.ts.map

package/dist/release/native-steps.js

@@ -0,0 +1,72 @@
+/**
+ * Native TypeScript release pipeline steps (#1860).
+ * Replaces python-steps.ts (scripts/ roadmap_render, reconcile_issues, build_dist).
+ */
+import { spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { fetchIssueStates, isTerminalLifecyclePath, reconcile, scanVbriefDir, } from "../intake/reconcile-issues.js";
+import { renderRoadmap } from "../render/roadmap-render.js";
+const BUILD_DIST_RUNNER = join(dirname(fileURLToPath(import.meta.url)), "build-dist-runner.js");
+export function refreshRoadmapNative(projectRoot) {
+    const pending = join(projectRoot, "vbrief", "pending");
+    const completed = join(projectRoot, "vbrief", "completed");
+    const roadmap = join(projectRoot, "ROADMAP.md");
+    const [ok, msg] = renderRoadmap(pending, roadmap, completed);
+    if (!ok) {
+        return [false, `roadmap:render failed: ${msg}`];
+    }
+    return [true, "ROADMAP.md re-rendered"];
+}
+export function checkVbriefLifecycleSyncNative(projectRoot, repo) {
+    const vbriefDir = join(projectRoot, "vbrief");
+    try {
+        const issueToVbriefs = scanVbriefDir(vbriefDir);
+        const issueStateMap = fetchIssueStates(repo, new Set(issueToVbriefs.keys()), {
+            cwd: projectRoot,
+        });
+        if (issueStateMap === null) {
+            return [false, -1, "failed to fetch issue states from gh"];
+        }
+        const report = reconcile(issueToVbriefs, issueStateMap);
+        const mismatches = [];
+        for (const entry of report.no_open_issue) {
+            const files = (entry.vbrief_files ?? []);
+            for (const rel of files) {
+                if (!isTerminalLifecyclePath(rel)) {
+                    mismatches.push(rel);
+                }
+            }
+        }
+        const count = mismatches.length;
+        if (count === 0) {
+            return [true, 0, "no mismatches"];
+        }
+        const suffix = count > 5 ? " ..." : "";
+        const preview = mismatches.slice(0, 5).join(", ");
+        const reason = `${count} closed-issue vBRIEF(s) not in completed/ or cancelled/: ${preview}${suffix}`;
+        return [false, count, reason];
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return [false, -1, msg];
+    }
+}
+export function runBuildNative(projectRoot, version, _seams = {}) {
+    if (!version) {
+        return [false, "build requires a release version"];
+    }
+    const env = { ...process.env, DEFT_RELEASE_VERSION: version };
+    const result = spawnSync(process.execPath, [BUILD_DIST_RUNNER, version, projectRoot], {
+        cwd: projectRoot,
+        encoding: "utf8",
+        env,
+    });
+    if (result.status !== 0) {
+        const msg = (result.stderr ?? result.stdout ?? "").trim() || `exit ${result.status ?? 1}`;
+        return [false, `build failed: ${msg}`];
+    }
+    const out = (result.stdout ?? "").trim();
+    return [true, `build ran clean (DEFT_RELEASE_VERSION=${version}) -> ${out}`];
+}
+//# sourceMappingURL=native-steps.js.map

package/dist/release/pipeline.js

@@ -4,10 +4,9 @@ import { prependUpgradeBanner, promoteChangelog, sectionForVersion } from "./cha
 import { EXIT_CONFIG_ERROR, EXIT_OK, EXIT_VIOLATION, RELEASE_ARTIFACTS, TOTAL_STEPS, VERIFY_DRAFT_INTERVAL_SECONDS, VERIFY_DRAFT_MAX_ATTEMPTS, } from "./constants.js";
 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 { checkVbriefLifecycleSyncNative, refreshRoadmapNative, runBuildNative, } from "./native-steps.js";
+import { todayIso } from "./paths.js";
 import { runReleaseCheck } from "./preflight.js";
-import { pyprojectPathFor, syncPyprojectForRelease } from "./pyproject-sync.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`);
@@ -17,16 +16,14 @@ export function runPipeline(config, seams = {}) {
     const version = config.version;
     const today = (seams.todayIso ?? todayIso)();
     const changelogPath = join(projectRoot, "CHANGELOG.md");
-    const scriptsDir = resolveScriptsDir();
     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) => runReleaseCheck(root));
-    const refreshRoadmapFn = seams.refreshRoadmap ?? ((root) => refreshRoadmap(root, scriptsDir, seams));
+    const refreshRoadmapFn = seams.refreshRoadmap ?? ((root) => refreshRoadmapNative(root));
     const checkVbriefFn = seams.checkVbriefLifecycleSync ??
-        ((root, repo) => checkVbriefLifecycleSync(root, repo, scriptsDir, seams));
-    const runBuildFn = seams.runBuild ?? ((root, v) => runBuild(root, scriptsDir, v, seams));
-    const runUvLockFn = seams.runUvLock ?? ((root) => runUvLock(root, seams));
+        ((root, repo) => checkVbriefLifecycleSyncNative(root, repo));
+    const runBuildFn = seams.runBuild ?? ((root, v) => runBuildNative(root, v, seams));
     // Step 1: dirty-tree guard.
     let label = "Pre-flight git status";
     if (config.dryRun) {
@@ -123,7 +120,7 @@ export function runPipeline(config, seams = {}) {
             return EXIT_VIOLATION;
         }
     }
-    // Step 6: CHANGELOG promotion + pyproject sync.
+    // Step 6: CHANGELOG promotion.
     label = "CHANGELOG promotion";
     if (!fileExists(changelogPath)) {
         emit(6, label, `FAIL (CHANGELOG.md not found at ${changelogPath})`);
@@ -148,28 +145,12 @@ export function runPipeline(config, seams = {}) {
     else {
         summaryNote = " no summary";
     }
-    const pyprojectPath = pyprojectPathFor(projectRoot);
-    const [pyprojectNote, promotedPyproject] = syncPyprojectForRelease(pyprojectPath, version, { dryRun: config.dryRun }, seams);
-    if (pyprojectNote.startsWith("FAIL")) {
-        emit(6, label, pyprojectNote);
-        return EXIT_CONFIG_ERROR;
-    }
     if (config.dryRun) {
-        emit(6, label, `DRYRUN (would rewrite CHANGELOG.md: ## [Unreleased] -> ## [${version}] - ${today}; new compare link added;${summaryNote}; ${pyprojectNote}; would run \`uv lock\` to refresh uv.lock to ${version})`);
+        emit(6, label, `DRYRUN (would rewrite CHANGELOG.md: ## [Unreleased] -> ## [${version}] - ${today}; new compare link added;${summaryNote})`);
     }
     else {
         writeFile(changelogPath, promotedChangelog);
-        let uvLockNote = "uv.lock unchanged (pyproject not modified)";
-        if (promotedPyproject !== null) {
-            writeFile(pyprojectPath, promotedPyproject);
-            const [uvOk, uvNote] = runUvLockFn(projectRoot);
-            uvLockNote = uvNote;
-            if (!uvOk) {
-                emit(6, label, `FAIL (${uvLockNote})`);
-                return EXIT_VIOLATION;
-            }
-        }
-        emit(6, label, `OK (## [${version}] - ${today};${summaryNote}; ${pyprojectNote}; ${uvLockNote})`);
+        emit(6, label, `OK (## [${version}] - ${today};${summaryNote})`);
     }
     // Step 7: ROADMAP refresh.
     label = "ROADMAP refresh (task roadmap:render)";

package/dist/release-e2e/rollback-bridge.d.ts

@@ -1,3 +1,3 @@
-/** Invoke release_rollback.main via Python until the TS rollback module lands (#1729). */
+/** Native TypeScript release rollback (#1860). */
 export declare function rollbackMain(argv: string[]): number;
 //# sourceMappingURL=rollback-bridge.d.ts.map

package/dist/release-e2e/rollback-bridge.js

@@ -1,20 +1,6 @@
-import { resolveScriptsDir } from "../release/paths.js";
-import { spawnText } from "../release/spawn.js";
-/** Invoke release_rollback.main via Python until the TS rollback module lands (#1729). */
+import { cmdRollback } from "../release-rollback/main.js";
+/** Native TypeScript release rollback (#1860). */
 export function rollbackMain(argv) {
-    const scriptsDir = resolveScriptsDir();
-    const code = [
-        "import sys",
-        `sys.path.insert(0, ${JSON.stringify(scriptsDir)})`,
-        "import release_rollback",
-        `sys.exit(release_rollback.main(${JSON.stringify(argv)}))`,
-    ].join("\n");
-    const frameworkRoot = scriptsDir.replace(/[/\\]scripts$/, "") || process.cwd();
-    const result = spawnText("uv", ["run", "python", "-c", code], {
-        cwd: frameworkRoot,
-        env: { ...process.env, PYTHONUTF8: "1" },
-        timeoutMs: 300_000,
-    });
-    return result.status ?? 1;
+    return cmdRollback(argv);
 }
 //# sourceMappingURL=rollback-bridge.js.map

package/dist/render/framework-commands.d.ts

@@ -26,8 +26,8 @@ export declare function formatFrameworkCommand(args: readonly string[], options?
     taskPrefix?: string | null;
 }): string;
 export declare function cmdCoreValidate(argv: readonly string[]): number;
-export declare function cmdCoreLint(argv: readonly string[]): number;
-export declare function cmdCoreTest(argv: readonly string[]): number;
+export declare function cmdCoreLint(_argv: readonly string[]): number;
+export declare function cmdCoreTest(_argv: readonly string[]): number;
 export declare function resolveFrameworkRoot(): string;
 export interface RunFrameworkCommandOptions {
     readonly projectRoot?: string;

package/dist/render/framework-commands.js

@@ -1,6 +1,7 @@
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { cmdDoctor } from "../doctor/main.js";
 function spec(name, entrypoint, opts = {}) {
     return { name, entrypoint, ...opts };
@@ -12,8 +13,6 @@ export const COMMANDS = {
     "core:validate": spec("core:validate", "framework_commands:_cmd_core_validate", {
         cwd: "framework",
     }),
-    "core:lint": spec("core:lint", "framework_commands:_cmd_core_lint", { cwd: "framework" }),
-    "core:test": spec("core:test", "framework_commands:_cmd_core_test", { cwd: "framework" }),
     doctor: spec("doctor", "doctor:cmd_doctor"),
     "session:start": spec("session:start", "session_start:main", {
         projectRootArg: "--project-root",
@@ -93,7 +92,7 @@ export const COMMANDS = {
         vbriefDirArg: "--vbrief-dir",
     }),
     build: spec("build", "build_dist:main", {
-        defaultArgs: ["--version", "__DEFT_VERSION__"],
+        defaultArgs: ["--version", "__DEFT_VERSION__", "--root", "__DEFT_ROOT__"],
         cwd: "framework",
     }),
     "check:consumer": aggregate("check:consumer", [
@@ -107,8 +106,6 @@ export const COMMANDS = {
     ]),
     "check:framework-source": aggregate("check:framework-source", [
         "core:validate",
-        "core:lint",
-        "core:test",
         "toolchain:check",
         "verify:stubs",
         "verify:links",
@@ -197,49 +194,13 @@ export function cmdCoreValidate(argv) {
     process.stdout.write(`✓ All ${files.length} markdown files validated\n`);
     return 0;
 }
-function runUv(args, frameworkRoot) {
-    try {
-        execFileSync("uv", ["--project", frameworkRoot, "run", ...args], {
-            encoding: "utf8",
-            stdio: "inherit",
-        });
-        return 0;
-    }
-    catch (err) {
-        const e = err;
-        return e.status ?? 1;
-    }
-}
-export function cmdCoreLint(argv) {
-    if (argv.length > 0) {
-        process.stderr.write(`error: core:lint does not accept arguments: ${argv.join(" ")}\n`);
-        return 2;
-    }
-    const ruffCode = runUv(["ruff", "check", "."], resolveFrameworkRoot());
-    if (ruffCode !== 0)
-        return ruffCode;
-    const targets = ["run.py"];
-    if (existsSync("tests"))
-        targets.push("tests");
-    return runUv(["python", "-m", "mypy", ...targets], resolveFrameworkRoot());
+export function cmdCoreLint(_argv) {
+    process.stderr.write("error: core:lint removed (#1860); use ts:check-lane\n");
+    return 2;
 }
-export function cmdCoreTest(argv) {
-    if (argv.length > 0) {
-        process.stderr.write(`error: core:test does not accept arguments: ${argv.join(" ")}\n`);
-        return 2;
-    }
-    if (!existsSync("tests")) {
-        process.stdout.write("no tests/ (vendored consumer) -- skipping\n");
-        return 0;
-    }
-    try {
-        execFileSync("python3", ["-m", "pytest", "tests"], { encoding: "utf8", stdio: "inherit" });
-        return 0;
-    }
-    catch (err) {
-        const e = err;
-        return e.status ?? 1;
-    }
+export function cmdCoreTest(_argv) {
+    process.stderr.write("error: core:test removed (#1860); use ts:check-lane\n");
+    return 2;
 }
 function resolveVersion() {
     try {
@@ -259,7 +220,12 @@ export function resolveFrameworkRoot() {
 function argvForSpec(commandSpec, argv, projectRoot, frameworkRoot) {
     const resolved = [];
     for (const item of commandSpec.defaultArgs ?? []) {
-        resolved.push(item === "__DEFT_VERSION__" ? resolveVersion() : item);
+        if (item === "__DEFT_VERSION__")
+            resolved.push(resolveVersion());
+        else if (item === "__DEFT_ROOT__")
+            resolved.push(frameworkRoot);
+        else
+            resolved.push(item);
     }
     if (commandSpec.projectRootArg)
         resolved.push(commandSpec.projectRootArg, projectRoot);
@@ -272,44 +238,81 @@ function argvForSpec(commandSpec, argv, projectRoot, frameworkRoot) {
     resolved.push(...normalizeTaskSeparator(argv));
     return resolved;
 }
+const BUILD_DIST_RUNNER = join(dirname(fileURLToPath(import.meta.url)), "..", "release", "build-dist-runner.js");
+function runBuildDistArgv(argv) {
+    let version = null;
+    let root = null;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--version")
+            version = argv[++i];
+        else if (arg === "--root")
+            root = argv[++i];
+    }
+    if (!version || !root) {
+        process.stderr.write("build: --version and --root are required\n");
+        return 2;
+    }
+    const result = spawnSync(process.execPath, [BUILD_DIST_RUNNER, version, root], {
+        cwd: root,
+        encoding: "utf8",
+        env: { ...process.env, DEFT_RELEASE_VERSION: version },
+    });
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    return result.status ?? 1;
+}
 const TS_INLINE = {
     "framework_commands:_cmd_core_validate": (argv) => cmdCoreValidate(argv),
-    "framework_commands:_cmd_core_lint": (argv) => cmdCoreLint(argv),
-    "framework_commands:_cmd_core_test": (argv) => cmdCoreTest(argv),
     "doctor:cmd_doctor": (argv) => cmdDoctor(argv),
+    "build_dist:main": (argv) => runBuildDistArgv(argv),
 };
-function spawnPythonEntrypoint(entrypoint, argv, cwd, frameworkRoot, noArgv) {
-    const scriptsDir = join(frameworkRoot, "scripts").replace(/\\/g, "/");
-    const code = [
-        "import sys, importlib, importlib.util, inspect, os",
-        `sys.path.insert(0, ${JSON.stringify(scriptsDir)})`,
-        `os.chdir(${JSON.stringify(cwd.replace(/\\/g, "/"))})`,
-        `entrypoint = ${JSON.stringify(entrypoint)}`,
-        "module_ref, _, func_name = entrypoint.partition(':')",
-        "if module_ref.endswith('.py'):",
-        "    path = __import__('pathlib').Path(module_ref)",
-        "    if not path.is_absolute():",
-        `        path = __import__('pathlib').Path(${JSON.stringify(scriptsDir)}) / module_ref`,
-        "    module_name = '_deft_cmd_' + path.stem.replace('-', '_')",
-        "    spec = importlib.util.spec_from_file_location(module_name, path)",
-        "    mod = importlib.util.module_from_spec(spec)",
-        "    spec.loader.exec_module(mod)",
-        "else:",
-        "    mod = importlib.import_module(module_ref)",
-        "func = getattr(mod, func_name)",
-        `argv = ${JSON.stringify(argv)}`,
-        "if not callable(func):",
-        "    raise TypeError('not callable')",
-        noArgv
-            ? "code = func() if len(inspect.signature(func).parameters) == 0 else func([])"
-            : "code = func() if len(inspect.signature(func).parameters) == 0 else func(argv)",
-        "sys.exit(int(code or 0))",
-    ].join("\n");
+const ENTRYPOINT_VERB = {
+    "session_start:main": "session-start",
+    "triage_welcome:main": "triage-welcome",
+    "triage_bootstrap:main": "triage-bootstrap",
+    "triage_summary:main": "triage-summary",
+    "triage_queue:main": "triage-queue",
+    "triage_actions:main": "triage-actions",
+    "triage_scope:main": "triage-scope",
+    "cache:main": "cache",
+    "capacity_show:main": "capacity-show",
+    "scope_demote:main": "scope-demote",
+    "toolchain-check.py:main": "toolchain-check",
+    "verify-stubs.py:main": "verify-stubs",
+    "validate-links.py:main": "validate-links",
+    "rule_ownership_lint:main": "rule-ownership-lint",
+    "preflight_branch:main": "verify-branch",
+    "verify_encoding:main": "verify-encoding",
+    "verify_vbrief_conformance:main": "vbrief-validate",
+    "preflight_gh:main": "preflight-gh",
+    "verify_scm_boundary:main": "verify-scm-boundary",
+    "verify_no_task_runtime:main": "verify-no-task-runtime",
+    "preflight_cache:main": "preflight-cache",
+    "preflight_wip_cap:main": "verify-wip-cap",
+    "pack_render:main": "pack-render",
+    "validate_strategy_output:main": "validate-strategy-output",
+    "vbrief_validate:main": "vbrief-validate",
+};
+function deftCliBin(frameworkRoot) {
+    return join(frameworkRoot, "packages", "cli", "dist", "bin.js");
+}
+function spawnDeftVerb(verb, argv, cwd, frameworkRoot) {
+    const bin = deftCliBin(frameworkRoot);
+    if (!existsSync(bin)) {
+        return {
+            code: 2,
+            stdout: "",
+            stderr: `deft CLI not built at ${bin}; run pnpm run build first\n`,
+        };
+    }
     try {
-        const stdout = execFileSync("uv", ["--project", frameworkRoot, "run", "python", "-c", code], {
-            cwd: frameworkRoot,
+        const stdout = execFileSync(process.execPath, [bin, verb, ...argv], {
+            cwd,
             encoding: "utf8",
-            env: { ...process.env, PYTHONUTF8: "1", DEFT_CACHE_DISABLE: "1" },
+            env: { ...process.env, DEFT_CACHE_DISABLE: "1" },
         });
         return { code: 0, stdout: typeof stdout === "string" ? stdout : "", stderr: "" };
     }
@@ -349,7 +352,23 @@ function invokeEntrypoint(entrypoint, argv, cwd, frameworkRoot, noArgv, capture)
         }
         return { code: inline(argv), stdout: "", stderr: "" };
     }
-    return spawnPythonEntrypoint(entrypoint, argv, cwd, frameworkRoot, noArgv);
+    const verb = ENTRYPOINT_VERB[entrypoint];
+    if (verb) {
+        const effectiveArgv = noArgv ? [] : argv;
+        const result = spawnDeftVerb(verb, effectiveArgv, cwd, frameworkRoot);
+        if (capture)
+            return result;
+        if (result.stdout)
+            process.stdout.write(result.stdout);
+        if (result.stderr)
+            process.stderr.write(result.stderr);
+        return result;
+    }
+    return {
+        code: 2,
+        stdout: "",
+        stderr: `unknown entrypoint (Python scripts removed #1860): ${entrypoint}\n`,
+    };
 }
 export function runFrameworkCommand(name, argv = [], options = {}) {
     const root = resolve(options.projectRoot ?? process.cwd());

package/dist/verify-source/cursor-tier1.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Deterministic gate: assert that Cursor is enumerated as a Tier-1 descriptor in
+ * both the swarm Phase 3 capability matrix and the review-cycle monitoring
+ * tier-selection table (#1877). Without this gate the "Cursor -> Tier 1" mapping
+ * is prose-trusted; a doc edit that drops the Cursor descriptor would silently
+ * re-open the misclassification (Cursor falling through to a blocking poll).
+ */
+export interface CursorTier1Target {
+    /** Project-root-relative path to the skill file. */
+    readonly path: string;
+    /** Human label for the surface, used in failure output. */
+    readonly label: string;
+    /** Whitespace-normalized substrings that MUST all be present. */
+    readonly markers: readonly string[];
+}
+export declare const CURSOR_TIER1_TARGETS: readonly CursorTier1Target[];
+/** Collapse all runs of whitespace to a single space (substring-containment normalization). */
+export declare function normalizeWhitespace(text: string): string;
+export interface CursorTier1Finding {
+    readonly path: string;
+    readonly label: string;
+    readonly missingMarkers: readonly string[];
+}
+export interface CursorTier1Result {
+    readonly code: 0 | 1 | 2;
+    readonly findings: readonly CursorTier1Finding[];
+    readonly message: string;
+    readonly stream: "stdout" | "stderr";
+}
+export interface CursorTier1Options {
+    readonly targets?: readonly CursorTier1Target[];
+    readonly quiet?: boolean;
+}
+export declare function evaluateCursorTier1(projectRoot: string, options?: CursorTier1Options): CursorTier1Result;
+//# sourceMappingURL=cursor-tier1.d.ts.map

package/dist/verify-source/cursor-tier1.js

@@ -0,0 +1,94 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+export const CURSOR_TIER1_TARGETS = [
+    {
+        path: "content/skills/deft-directive-swarm/SKILL.md",
+        label: "swarm Phase 3 capability matrix",
+        markers: [
+            "Probe for the Cursor `Task` tool",
+            "cursor-composer",
+            "cursor-cloud-agent",
+            "Step 2e: Cursor Launch",
+        ],
+    },
+    {
+        path: "content/skills/deft-directive-review-cycle/SKILL.md",
+        label: "review-cycle monitoring tier selection",
+        markers: [
+            "cursor-composer",
+            "cursor-cloud-agent",
+            "Tier 1 with the backgrounded Cursor `Task` poller path",
+            "Heartbeat contract for Cursor pollers",
+        ],
+    },
+];
+/** Collapse all runs of whitespace to a single space (substring-containment normalization). */
+export function normalizeWhitespace(text) {
+    return text.replace(/\s+/g, " ");
+}
+export function evaluateCursorTier1(projectRoot, options = {}) {
+    const root = resolve(projectRoot);
+    let isDir = false;
+    try {
+        isDir = statSync(root).isDirectory();
+    }
+    catch {
+        isDir = false;
+    }
+    if (!isDir) {
+        return {
+            code: 2,
+            findings: [],
+            message: `verify_cursor_tier1: --project-root is not a directory: ${root}\n` +
+                "  Recovery: pass an existing directory path.",
+            stream: "stderr",
+        };
+    }
+    const targets = options.targets ?? CURSOR_TIER1_TARGETS;
+    const findings = [];
+    for (const target of targets) {
+        const full = join(root, target.path);
+        if (!existsSync(full)) {
+            return {
+                code: 2,
+                findings: [...findings],
+                message: `verify_cursor_tier1: required skill file not found: ${target.path}\n` +
+                    "  Recovery: run from the framework source root, or update CURSOR_TIER1_TARGETS if the skill moved.",
+                stream: "stderr",
+            };
+        }
+        let normalized;
+        try {
+            normalized = normalizeWhitespace(readFileSync(full, { encoding: "utf8" }));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+                code: 2,
+                findings: [...findings],
+                message: `verify_cursor_tier1: could not read ${target.path}: ${msg}`,
+                stream: "stderr",
+            };
+        }
+        const missing = target.markers.filter((marker) => !normalized.includes(normalizeWhitespace(marker)));
+        if (missing.length > 0) {
+            findings.push({ path: target.path, label: target.label, missingMarkers: missing });
+        }
+    }
+    if (findings.length > 0) {
+        const header = "verify_cursor_tier1: Cursor is not fully enumerated as a Tier-1 descriptor (#1877).\n" +
+            "  Root cause: a Cursor agent has a first-class backgroundable sub-agent primitive (the Task tool) and\n" +
+            "  is therefore Tier 1 / Approach 1. If the matrices below drop the Cursor descriptor, a Cursor session\n" +
+            "  silently degrades to the Approach-3 blocking poll. Re-add the missing marker(s):";
+        const body = findings
+            .map((f) => `  ${f.path} (${f.label}) missing: ${f.missingMarkers.map((m) => `"${m}"`).join(", ")}`)
+            .join("\n");
+        return { code: 1, findings, message: `${header}\n${body}`, stream: "stderr" };
+    }
+    const msg = `verify_cursor_tier1: Cursor enumerated as a Tier-1 descriptor in ${targets.length} matrix surface(s) (#1877).`;
+    if (options.quiet) {
+        return { code: 0, findings: [], message: "", stream: "stdout" };
+    }
+    return { code: 0, findings: [], message: msg, stream: "stdout" };
+}
+//# sourceMappingURL=cursor-tier1.js.map

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

@@ -1,5 +1,6 @@
 export * from "./code-structure-validate.js";
 export * from "./content-manifest.js";
+export * from "./cursor-tier1.js";
 export * from "./python-call-scan.js";
 export * from "./rule-ownership-lint.js";
 export * from "./scm-boundary.js";

package/dist/verify-source/index.js

@@ -1,5 +1,6 @@
 export * from "./code-structure-validate.js";
 export * from "./content-manifest.js";
+export * from "./cursor-tier1.js";
 export * from "./python-call-scan.js";
 export * from "./rule-ownership-lint.js";
 export * from "./scm-boundary.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.62.0",
+  "version": "0.64.0",
   "description": "TypeScript engine core for the Directive framework.",
   "type": "module",
   "main": "./dist/index.js",
@@ -229,11 +229,15 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-content": "^0.62.0",
-    "@deftai/directive-types": "^0.62.0"
+    "@deftai/directive-content": "^0.64.0",
+    "@deftai/directive-types": "^0.64.0",
+    "archiver": "^8.0.0"
   },
   "scripts": {
     "build": "tsc -b",
     "test": "pnpm -w exec vitest run --coverage packages/core/src"
+  },
+  "devDependencies": {
+    "@types/archiver": "^8.0.0"
   }
 }

package/dist/release/pyproject-sync.d.ts

@@ -1,6 +0,0 @@
-import type { ReleaseSeams } from "./types.js";
-export declare function syncPyprojectForRelease(pyprojectPath: string, version: string, options: {
-    dryRun: boolean;
-}, seams?: ReleaseSeams): [string, string | null];
-export declare function pyprojectPathFor(projectRoot: string): string;
-//# sourceMappingURL=pyproject-sync.d.ts.map

package/dist/release/pyproject-sync.js

@@ -1,52 +0,0 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { updatePyprojectVersion } from "./pyproject.js";
-import { NonPublishableVersionError, toPep440 } from "./version.js";
-export function syncPyprojectForRelease(pyprojectPath, version, options, seams = {}) {
-    const exists = seams.fileExists ??
-        ((p) => {
-            try {
-                return existsSync(p) && statSync(p).isFile();
-            }
-            catch {
-                return false;
-            }
-        });
-    const read = seams.readFile ?? ((p) => readFileSync(p, "utf8"));
-    if (!exists(pyprojectPath)) {
-        return ["no pyproject.toml; skipping sync", null];
-    }
-    let pepVersion;
-    try {
-        pepVersion = toPep440(version);
-    }
-    catch (err) {
-        if (err instanceof NonPublishableVersionError) {
-            return [`non-publishable tag (${err.message}); skipping pyproject sync`, null];
-        }
-        if (err instanceof Error) {
-            return [`FAIL (cannot normalize version to PEP 440: ${err.message})`, null];
-        }
-        return [`FAIL (cannot normalize version to PEP 440: ${String(err)})`, null];
-    }
-    const original = read(pyprojectPath);
-    let newText;
-    try {
-        newText = updatePyprojectVersion(original, pepVersion);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return [`FAIL (pyproject.toml: ${msg})`, null];
-    }
-    if (newText === original) {
-        return [`pyproject already at ${pepVersion}`, null];
-    }
-    if (options.dryRun) {
-        return [`pyproject [project].version -> ${pepVersion}`, null];
-    }
-    return [`pyproject [project].version -> ${pepVersion}`, newText];
-}
-export function pyprojectPathFor(projectRoot) {
-    return join(projectRoot, "pyproject.toml");
-}
-//# sourceMappingURL=pyproject-sync.js.map

package/dist/release/pyproject.d.ts

@@ -1,3 +0,0 @@
-/** Rewrite [project].version in pyproject.toml content (#771). */
-export declare function updatePyprojectVersion(text: string, version: string): string;
-//# sourceMappingURL=pyproject.d.ts.map

package/dist/release/pyproject.js

@@ -1,33 +0,0 @@
-import { PYPROJECT_VERSION_LINE_RE } from "./constants.js";
-/** Rewrite [project].version in pyproject.toml content (#771). */
-export function updatePyprojectVersion(text, version) {
-    if (typeof text !== "string") {
-        throw new Error(`text must be a string, got ${typeof text}`);
-    }
-    if (typeof version !== "string" || !version.trim()) {
-        throw new Error("version must be a non-empty string");
-    }
-    const lines = text.split(/(?<=\n)/);
-    let inProjectSection = false;
-    for (let idx = 0; idx < lines.length; idx += 1) {
-        const line = lines[idx] ?? "";
-        const stripped = line.trim();
-        if (!stripped || stripped.startsWith("#")) {
-            continue;
-        }
-        if (stripped.startsWith("[") && stripped.endsWith("]")) {
-            inProjectSection = stripped === "[project]";
-            continue;
-        }
-        if (inProjectSection && PYPROJECT_VERSION_LINE_RE.test(stripped)) {
-            const newLine = line.replace(PYPROJECT_VERSION_LINE_RE, `version = "${version}"`);
-            if (newLine === line) {
-                return text;
-            }
-            lines[idx] = newLine;
-            return lines.join("");
-        }
-    }
-    throw new Error("pyproject.toml has no [project] section with a version key");
-}
-//# sourceMappingURL=pyproject.js.map

package/dist/release/python-steps.d.ts

@@ -1,6 +0,0 @@
-import type { ReleaseSeams } from "./types.js";
-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-steps.d.ts.map

package/dist/release/python-steps.js

@@ -1,143 +0,0 @@
-/**
- * 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";
-function runUvPython(_scriptsDir, code, cwd, env = process.env, seams = {}) {
-    const spawn = seams.spawnText ?? spawnText;
-    return spawn("uv", ["run", "python", "-c", code], {
-        cwd,
-        env: { ...env, PYTHONUTF8: "1" },
-        timeoutMs: 300_000,
-    });
-}
-export function refreshRoadmap(projectRoot, scriptsDir, seams = {}) {
-    const pending = join(projectRoot, "vbrief", "pending");
-    const roadmap = join(projectRoot, "ROADMAP.md");
-    const completed = join(projectRoot, "vbrief", "completed");
-    const code = [
-        "import sys",
-        `sys.path.insert(0, ${JSON.stringify(scriptsDir)})`,
-        "import roadmap_render",
-        `ok, msg = roadmap_render.render_roadmap(${JSON.stringify(pending)}, ${JSON.stringify(roadmap)}, completed_dir=${JSON.stringify(completed)})`,
-        "if ok:",
-        "    sys.exit(0)",
-        "print(msg, file=sys.stderr)",
-        "sys.exit(1)",
-    ].join("\n");
-    const result = runUvPython(scriptsDir, code, projectRoot, process.env, seams);
-    if (result.status !== 0) {
-        const msg = result.stderr.trim() || result.stdout.trim();
-        return [false, `roadmap:render failed: ${msg}`];
-    }
-    return [true, "ROADMAP.md re-rendered"];
-}
-export function checkVbriefLifecycleSync(projectRoot, repo, scriptsDir, seams = {}) {
-    const code = [
-        "import json, sys",
-        "from pathlib import Path",
-        `scripts_dir = Path(${JSON.stringify(scriptsDir)})`,
-        "sys.path.insert(0, str(scripts_dir))",
-        "try:",
-        "    import reconcile_issues",
-        "except ImportError as exc:",
-        "    print(json.dumps({'ok': False, 'mismatch_count': -1, 'reason': f'reconcile_issues import failed: {exc}'}))",
-        "    sys.exit(0)",
-        `project_root = Path(${JSON.stringify(projectRoot)})`,
-        `repo = ${JSON.stringify(repo)}`,
-        "vbrief_dir = project_root / 'vbrief'",
-        "if not vbrief_dir.is_dir():",
-        "    print(json.dumps({'ok': False, 'mismatch_count': -1, 'reason': f'vbrief directory not found at {vbrief_dir}'}))",
-        "    sys.exit(0)",
-        "issue_to_vbriefs = reconcile_issues.scan_vbrief_dir(vbrief_dir)",
-        "issue_state_map = reconcile_issues.fetch_issue_states(repo, set(issue_to_vbriefs.keys()), cwd=project_root)",
-        "if issue_state_map is None:",
-        "    print(json.dumps({'ok': False, 'mismatch_count': -1, 'reason': 'failed to fetch issue states from gh'}))",
-        "    sys.exit(0)",
-        "report = reconcile_issues.reconcile(issue_to_vbriefs, issue_state_map)",
-        "mismatches = [rel for entry in report.get('no_open_issue', []) for rel in entry.get('vbrief_files', []) if not reconcile_issues.is_terminal_lifecycle_path(rel)]",
-        "count = len(mismatches)",
-        "if count == 0:",
-        "    print(json.dumps({'ok': True, 'mismatch_count': 0, 'reason': 'no mismatches'}))",
-        "else:",
-        "    suffix = ' ...' if count > 5 else ''",
-        "    preview = ', '.join(mismatches[:5])",
-        "    reason = f'{count} closed-issue vBRIEF(s) not in completed/ or cancelled/: {preview}{suffix}'",
-        "    print(json.dumps({'ok': False, 'mismatch_count': count, 'reason': reason}))",
-    ].join("\n");
-    const result = runUvPython(scriptsDir, code, projectRoot, process.env, seams);
-    try {
-        const payload = JSON.parse(result.stdout.trim());
-        return [payload.ok, payload.mismatch_count, payload.reason];
-    }
-    catch {
-        return [
-            false,
-            -1,
-            `reconcile_issues bridge failed: ${result.stderr.trim() || result.stdout.trim()}`,
-        ];
-    }
-}
-export function runBuild(projectRoot, scriptsDir, version, seams = {}) {
-    const env = { ...process.env };
-    if (version) {
-        env.DEFT_RELEASE_VERSION = version;
-    }
-    else {
-        delete env.DEFT_RELEASE_VERSION;
-    }
-    const code = [
-        "import sys",
-        "from pathlib import Path",
-        `sys.path.insert(0, ${JSON.stringify(scriptsDir)})`,
-        "from framework_commands import run_framework_command",
-        `root = Path(${JSON.stringify(projectRoot)})`,
-        "result = run_framework_command('build', project_root=root, framework_root=root)",
-        "sys.exit(result.code)",
-    ].join("\n");
-    const result = runUvPython(scriptsDir, code, projectRoot, env, seams);
-    if (result.status !== 0) {
-        return [false, `build failed (exit ${result.status})`];
-    }
-    const suffix = version ? ` (DEFT_RELEASE_VERSION=${version})` : "";
-    return [true, `build ran clean${suffix}`];
-}
-export function runUvLock(projectRoot, seams = {}) {
-    const exists = seams.fileExists ??
-        ((p) => {
-            try {
-                return existsSync(p) && statSync(p).isFile();
-            }
-            catch {
-                return false;
-            }
-        });
-    if (!exists(join(projectRoot, "pyproject.toml"))) {
-        return [true, "no pyproject.toml; skipping uv lock"];
-    }
-    const whichUv = seams.whichUv ?? defaultWhich;
-    const uvPath = whichUv("uv");
-    if (uvPath === null) {
-        process.stderr.write("WARNING: uv binary not on PATH; skipping uv.lock regeneration " +
-            "(see #774). Run `uv lock` manually before pushing the release tag.\n");
-        return [true, "uv binary not on PATH; skipping uv lock"];
-    }
-    const spawn = seams.spawnText ?? spawnText;
-    const result = spawn(uvPath, ["lock"], { cwd: projectRoot, timeoutMs: 300_000 });
-    if (result.status !== 0) {
-        const stderr = result.stderr.trim();
-        return [false, `uv lock failed (exit ${result.status}): ${stderr}`];
-    }
-    return [true, "uv.lock regenerated"];
-}
-//# sourceMappingURL=python-steps.js.map