@deftai/directive-core 0.55.0

package/dist/release/pipeline.js

@@ -0,0 +1,314 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { prependUpgradeBanner, promoteChangelog, sectionForVersion } from "./changelog.js";
+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 { pyprojectPathFor, syncPyprojectForRelease } from "./pyproject-sync.js";
+import { checkVbriefLifecycleSync, refreshRoadmap, runBuild, runCi, runUvLock, } from "./python-bridge.js";
+import { isPrereleaseTag } from "./version.js";
+export function emit(step, label, status, target = process.stderr) {
+    target.write(`[${step}/${TOTAL_STEPS}] ${label}... ${status}\n`);
+}
+export function runPipeline(config, seams = {}) {
+    const projectRoot = config.projectRoot;
+    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) => runCi(root, scriptsDir, seams));
+    const refreshRoadmapFn = seams.refreshRoadmap ?? ((root) => refreshRoadmap(root, scriptsDir, seams));
+    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));
+    // Step 1: dirty-tree guard.
+    let label = "Pre-flight git status";
+    if (config.dryRun) {
+        emit(1, label, `DRYRUN (would run \`git status --porcelain\` in ${projectRoot})`);
+    }
+    else {
+        const [ok, output] = checkGitClean(projectRoot, seams);
+        if (ok) {
+            emit(1, label, "OK (tree clean)");
+        }
+        else if (config.allowDirty) {
+            emit(1, label, `WARN (dirty, --allow-dirty set):\n${output}`);
+        }
+        else {
+            emit(1, label, "FAIL (working tree is dirty; commit/stash or pass --allow-dirty)");
+            process.stderr.write(`${output}\n`);
+            return EXIT_VIOLATION;
+        }
+    }
+    // Step 2: branch guard.
+    label = `Pre-flight branch == ${config.baseBranch}`;
+    if (config.dryRun) {
+        emit(2, label, `DRYRUN (would assert current branch == ${config.baseBranch})`);
+    }
+    else {
+        const branch = currentBranch(projectRoot, seams);
+        if (branch === config.baseBranch) {
+            emit(2, label, `OK (on ${branch})`);
+        }
+        else {
+            emit(2, label, `FAIL (on '${branch}'; expected '${config.baseBranch}')`);
+            return EXIT_VIOLATION;
+        }
+    }
+    // Step 3: vBRIEF lifecycle sync (#734).
+    label = "Pre-flight vBRIEF lifecycle sync";
+    if (config.allowVbriefDrift) {
+        emit(3, label, "SKIP (--allow-vbrief-drift)");
+    }
+    else if (config.dryRun) {
+        emit(3, label, "DRYRUN (would scan vbrief/ + gh open issues for closed-issue mismatches)");
+    }
+    else {
+        const [ok, mismatchCount, reason] = checkVbriefFn(projectRoot, config.repo);
+        if (ok) {
+            emit(3, label, "OK (no mismatches)");
+        }
+        else if (mismatchCount === -1) {
+            emit(3, label, `FAIL (${reason})`);
+            return EXIT_CONFIG_ERROR;
+        }
+        else {
+            emit(3, label, `FAIL (${mismatchCount} mismatches; run task reconcile:issues -- --apply-lifecycle-fixes to fix, or pass --allow-vbrief-drift to override)`);
+            process.stderr.write(`${reason}\n`);
+            return EXIT_VIOLATION;
+        }
+    }
+    // Step 4: tag availability pre-flight (#784).
+    label = "Pre-flight tag availability";
+    if (config.dryRun) {
+        emit(4, label, `DRYRUN (would verify v${version} tag not present locally / on origin / as GitHub release on ${config.repo})`);
+    }
+    else {
+        const checkTag = seams.checkTagAvailable ??
+            ((v, r, root) => checkTagAvailable(v, r, root, seams));
+        const [ok, reason] = checkTag(version, config.repo, projectRoot);
+        if (ok) {
+            emit(4, label, `OK (${reason})`);
+        }
+        else {
+            emit(4, label, `FAIL (${reason})`);
+            return EXIT_VIOLATION;
+        }
+    }
+    // Step 5: CI.
+    label = "Pre-flight CI (task ci:local | fallback task check)";
+    if (config.skipCi) {
+        emit(5, label, "SKIP (--skip-ci)");
+    }
+    else if (config.dryRun) {
+        emit(5, label, "DRYRUN (would run task ci:local with task check fallback)");
+    }
+    else {
+        const [ok, reason] = runCiFn(projectRoot);
+        if (ok) {
+            emit(5, label, `OK (${reason})`);
+        }
+        else {
+            emit(5, label, `FAIL (${reason})`);
+            return EXIT_VIOLATION;
+        }
+    }
+    // Step 6: CHANGELOG promotion + pyproject sync.
+    label = "CHANGELOG promotion";
+    if (!fileExists(changelogPath)) {
+        emit(6, label, `FAIL (CHANGELOG.md not found at ${changelogPath})`);
+        return EXIT_CONFIG_ERROR;
+    }
+    const originalChangelog = readFile(changelogPath);
+    let promotedChangelog;
+    try {
+        promotedChangelog = promoteChangelog(originalChangelog, version, config.repo, today, config.summary);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        emit(6, label, `FAIL (${msg})`);
+        return EXIT_CONFIG_ERROR;
+    }
+    let summaryNote;
+    if (config.summary) {
+        const truncated = config.summary.slice(0, 60);
+        const truncationSuffix = config.summary.length > 60 ? "..." : "";
+        summaryNote = ` summary: "${truncated}${truncationSuffix}"`;
+    }
+    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})`);
+    }
+    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})`);
+    }
+    // Step 7: ROADMAP refresh.
+    label = "ROADMAP refresh (task roadmap:render)";
+    if (config.dryRun) {
+        emit(7, label, "DRYRUN (would run task roadmap:render)");
+    }
+    else {
+        const [ok, reason] = refreshRoadmapFn(projectRoot);
+        if (ok) {
+            emit(7, label, `OK (${reason})`);
+        }
+        else {
+            emit(7, label, `FAIL (${reason})`);
+            return EXIT_VIOLATION;
+        }
+    }
+    // Step 8: build dist.
+    label = `Build dist (task build, DEFT_RELEASE_VERSION=${version})`;
+    if (config.skipBuild) {
+        emit(8, label, "SKIP (--skip-build)");
+    }
+    else if (config.dryRun) {
+        emit(8, label, `DRYRUN (would run \`task build\` with DEFT_RELEASE_VERSION=${version})`);
+    }
+    else {
+        const [ok, reason] = runBuildFn(projectRoot, version);
+        if (ok) {
+            emit(8, label, `OK (${reason})`);
+        }
+        else {
+            emit(8, label, `FAIL (${reason})`);
+            return EXIT_VIOLATION;
+        }
+    }
+    // Step 9: commit release artifacts.
+    label = `Commit release artifacts (${RELEASE_ARTIFACTS.join(", ")})`;
+    if (config.skipTag) {
+        emit(9, label, "SKIP (--skip-tag)");
+    }
+    else if (config.dryRun) {
+        emit(9, label, `DRYRUN (would run \`git add ${RELEASE_ARTIFACTS.join(" ")}\` + \`git commit -m '${releaseCommitSubject(version)}'\`)`);
+    }
+    else {
+        const [ok, reason] = commitReleaseArtifacts(projectRoot, version, seams);
+        if (ok) {
+            emit(9, label, `OK (${reason})`);
+        }
+        else {
+            emit(9, label, `FAIL (${reason})`);
+            return EXIT_VIOLATION;
+        }
+    }
+    // Step 10: git tag.
+    label = `Tag v${version}`;
+    if (config.skipTag) {
+        emit(10, label, "SKIP (--skip-tag)");
+    }
+    else if (config.dryRun) {
+        emit(10, label, `DRYRUN (would run \`git tag -a v${version} -m 'Release v${version}'\`)`);
+    }
+    else {
+        const [ok, reason] = createTag(projectRoot, version, seams);
+        if (ok) {
+            emit(10, label, `OK (${reason})`);
+        }
+        else {
+            emit(10, label, `FAIL (${reason})`);
+            return EXIT_VIOLATION;
+        }
+    }
+    // Step 11: push branch + tag atomically.
+    label = `Push ${config.baseBranch} + v${version} to origin (atomic)`;
+    if (config.skipTag) {
+        emit(11, label, "SKIP (--skip-tag)");
+    }
+    else if (config.dryRun) {
+        emit(11, label, `DRYRUN (would run \`git push --atomic origin ${config.baseBranch} v${version}\`)`);
+    }
+    else {
+        const [ok, reason] = pushRelease(projectRoot, version, config.baseBranch, seams);
+        if (ok) {
+            emit(11, label, `OK (${reason})`);
+        }
+        else {
+            emit(11, label, `FAIL (${reason})`);
+            return EXIT_VIOLATION;
+        }
+    }
+    // Step 12: GitHub release.
+    const prerelease = isPrereleaseTag(version);
+    const draftSuffix = config.draft ? " (draft)" : " (PUBLIC)";
+    const prereleaseSuffix = prerelease ? " (prerelease)" : "";
+    label = `GitHub release v${version}${draftSuffix}${prereleaseSuffix}`;
+    let createSucceeded = false;
+    if (config.skipRelease) {
+        emit(12, label, "SKIP (--skip-release)");
+    }
+    else if (config.dryRun) {
+        const draftFlag = config.draft ? " --draft" : "";
+        const prereleaseFlag = prerelease ? " --prerelease" : "";
+        emit(12, label, `DRYRUN (would run \`gh release create v${version} --repo ${config.repo}${draftFlag}${prereleaseFlag} ...\`)`);
+    }
+    else {
+        let notes = sectionForVersion(promotedChangelog, version);
+        notes = prependUpgradeBanner(notes, config.repo, projectRoot, readTextFile);
+        const [ok, reason] = createGithubRelease(projectRoot, version, config.repo, notes, { draft: config.draft, prerelease }, seams);
+        if (ok) {
+            emit(12, label, `OK (${reason})`);
+            createSucceeded = true;
+        }
+        else {
+            emit(12, label, `FAIL (${reason})`);
+            return EXIT_VIOLATION;
+        }
+    }
+    // Step 13: post-create verify-isDraft gate (#724).
+    label = `Verify draft state of v${version} (#724 defense-in-depth)`;
+    if (config.skipRelease) {
+        emit(13, label, "SKIP (--skip-release)");
+    }
+    else if (!config.draft) {
+        emit(13, label, "SKIP (--no-draft; intentional public release)");
+    }
+    else if (config.dryRun) {
+        emit(13, label, `DRYRUN (would poll \`gh release view v${version} --json isDraft\` up to ${VERIFY_DRAFT_MAX_ATTEMPTS}x at ${VERIFY_DRAFT_INTERVAL_SECONDS}s intervals; auto-flip via \`gh release edit --draft=true\` on isDraft=false)`);
+    }
+    else if (!createSucceeded) {
+        emit(13, label, "SKIP (release was not created in this run)");
+    }
+    else {
+        const [ok, reason] = verifyReleaseDraft(projectRoot, version, config.repo, {
+            maxAttempts: VERIFY_DRAFT_MAX_ATTEMPTS,
+            interval: VERIFY_DRAFT_INTERVAL_SECONDS,
+            sleep: seams.sleep,
+        }, seams);
+        if (ok) {
+            emit(13, label, `OK (${reason})`);
+        }
+        else {
+            emit(13, label, `FAIL (${reason})`);
+            return EXIT_VIOLATION;
+        }
+    }
+    process.stderr.write(`Release v${version} pipeline complete (dry_run=${config.dryRun ? "True" : "False"}, skip_tag=${config.skipTag ? "True" : "False"}, skip_release=${config.skipRelease ? "True" : "False"}).\n`);
+    return EXIT_OK;
+}
+//# sourceMappingURL=pipeline.js.map

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,3 @@
+/** 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

@@ -0,0 +1,33 @@
+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-bridge.d.ts

@@ -0,0 +1,7 @@
+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

package/dist/release/python-bridge.js

@@ -0,0 +1,144 @@
+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 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");
+    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-bridge.js.map

package/dist/release/spawn.d.ts

@@ -0,0 +1,8 @@
+import type { SpawnResult } from "./types.js";
+export declare function defaultWhich(name: string): string | null;
+export declare function spawnText(cmd: string, args: readonly string[], options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+}): SpawnResult;
+//# sourceMappingURL=spawn.d.ts.map

package/dist/release/spawn.js

@@ -0,0 +1,44 @@
+import { spawnSync } from "node:child_process";
+import { SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
+export function defaultWhich(name) {
+    const result = spawnSync("which", [name], { encoding: "utf8" });
+    if (result.status !== 0) {
+        return null;
+    }
+    const path = (result.stdout ?? "").trim();
+    return path || null;
+}
+export function spawnText(cmd, args, options = {}) {
+    const result = spawnSync(cmd, [...args], {
+        cwd: options.cwd,
+        env: options.env ?? process.env,
+        encoding: "utf8",
+        timeout: options.timeoutMs,
+        maxBuffer: SUBPROCESS_MAX_BUFFER,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let status = result.status;
+    let stderr = typeof result.stderr === "string" ? result.stderr : "";
+    if (status === null) {
+        if (result.signal !== null && result.signal !== undefined) {
+            status = 128;
+        }
+        else if (result.error) {
+            status = 2;
+            // ENOBUFS (stdout over maxBuffer) and similar spawn failures leave stderr
+            // empty; surface the error so callers never report a blank reason (#1867).
+            if (stderr.trim().length === 0) {
+                stderr = result.error.message;
+            }
+        }
+        else {
+            status = 0;
+        }
+    }
+    return {
+        status,
+        stdout: typeof result.stdout === "string" ? result.stdout : "",
+        stderr,
+    };
+}
+//# sourceMappingURL=spawn.js.map

package/dist/release/types.d.ts

@@ -0,0 +1,58 @@
+export interface ReleaseConfig {
+    readonly version: string;
+    readonly repo: string;
+    readonly baseBranch: string;
+    readonly projectRoot: string;
+    readonly dryRun: boolean;
+    readonly skipTag: boolean;
+    readonly skipRelease: boolean;
+    readonly allowDirty: boolean;
+    readonly draft: boolean;
+    readonly skipCi: boolean;
+    readonly skipBuild: boolean;
+    readonly summary: string | null;
+    readonly allowVbriefDrift: boolean;
+}
+export interface ReleaseFlags {
+    readonly help: boolean;
+    readonly version: string | null;
+    readonly repo: string | null;
+    readonly baseBranch: string;
+    readonly projectRoot: string | null;
+    readonly dryRun: boolean;
+    readonly skipTag: boolean;
+    readonly skipRelease: boolean;
+    readonly allowDirty: boolean;
+    readonly allowVbriefDrift: boolean;
+    readonly skipCi: boolean;
+    readonly skipBuild: boolean;
+    readonly draft: boolean;
+    readonly summary: string | null;
+    readonly unknown: readonly string[];
+}
+export interface SpawnResult {
+    readonly status: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ReleaseSeams {
+    readonly todayIso?: () => string;
+    readonly sleep?: (seconds: number) => void;
+    readonly whichGh?: (name: string) => string | null;
+    readonly whichUv?: (name: string) => string | null;
+    readonly spawnText?: (cmd: string, args: readonly string[], options: {
+        cwd?: string;
+        env?: NodeJS.ProcessEnv;
+        timeoutMs?: number;
+    }) => SpawnResult;
+    readonly writeFile?: (path: string, content: string) => void;
+    readonly readFile?: (path: string) => string;
+    readonly fileExists?: (path: string) => boolean;
+    readonly runCi?: (projectRoot: string) => [boolean, string];
+    readonly refreshRoadmap?: (projectRoot: string) => [boolean, string];
+    readonly checkVbriefLifecycleSync?: (projectRoot: string, repo: string) => [boolean, number, string];
+    readonly runBuild?: (projectRoot: string, version: string | null) => [boolean, string];
+    readonly runUvLock?: (projectRoot: string) => [boolean, string];
+    readonly checkTagAvailable?: (version: string, repo: string, projectRoot: string) => [boolean, string];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/release/types.js

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