@deftai/directive-core 0.90.0 → 0.91.0

package/dist/scm/readiness.js

@@ -0,0 +1,421 @@
+/**
+ * SCM tooling + auth readiness probe for mismatched / headless envs (#2275).
+ *
+ * Framework-local gates (session:start, verify:*, xbrief:preflight, doctor,
+ * scope:*) run without GitHub credentials. SCM-dependent gates (triage:queue,
+ * issue:ingest, pr:*, reconcile:issues, cache:fetch-all, scm:*) need `gh`/`ghx`
+ * on PATH and either host credential store auth or an injected token
+ * (`GH_TOKEN` / `GITHUB_TOKEN` / `GH_ENTERPRISE_TOKEN`).
+ *
+ * This module:
+ *   1. Detects binary + auth state in the *current* execution env (not the
+ *      install host).
+ *   2. Emits a clear one-line diagnostic for session-start and CLI surfaces.
+ *   3. Lists which SCM-dependent gates are skipped when readiness is false.
+ *   4. Supplies fail-loud error text so SCM verbs never fail opaquely.
+ *
+ * Hot-path rule (#2991): the default "shallow" probe is local-only (PATH +
+ * env token presence + optional short `gh auth status`). Deep API validation
+ * is opt-in via `deep: true` (session:start --with-network).
+ */
+import { spawnSync } from "node:child_process";
+import { findInjectedToken, GITHUB_AUTH_MODE_HOST_GH, GITHUB_AUTH_MODE_INJECTED_TOKEN, inferGithubAuthMode, validateGithubAuthForWorker, } from "../intake/github-auth-modes.js";
+import { getPlatformCapabilities, probeRuntimeCapabilities, } from "../intake/platform-capabilities.js";
+import { defaultWhich } from "./binary.js";
+import { BINARY_PREFERENCE } from "./constants.js";
+import { ScmStubError } from "./errors.js";
+/** Named SCM-dependent surfaces that need gh/ghx + auth (#2275). */
+export const SCM_DEPENDENT_GATES = [
+    "triage:queue",
+    "triage:welcome (network hydrate)",
+    "issue:ingest",
+    "reconcile:issues",
+    "pr:*",
+    "cache:fetch-all",
+    "scm:*",
+    "github-auth-modes (deep)",
+    "umbrella:current-shape",
+];
+const REMEDIATION_BINARY_ABSENT = "Remediation for missing gh/ghx in this execution env:\n" +
+    "  - Install GitHub CLI in the *execution* environment (https://cli.github.com/)\n" +
+    "  - Or install ghx (`task setup:ghx` / directive setup:ghx) then ensure PATH is updated\n" +
+    "  - Or run SCM-dependent gates from a matched env where gh is already installed\n" +
+    "  - Framework-local gates (session:start, verify:*, xbrief:preflight, doctor, scope:*) do not need SCM";
+const REMEDIATION_MISSING_TOKEN = "Remediation for missing injected token (cloud/headless auth mode):\n" +
+    "  - Pass GH_TOKEN, GITHUB_TOKEN, or GH_ENTERPRISE_TOKEN into the execution env\n" +
+    "  - Keep token values out of prompts and transcripts; inject via host secrets only\n" +
+    "  - Or run SCM-dependent gates from a matched host-gh env instead";
+const REMEDIATION_UNAUTHENTICATED = "Remediation for unauthenticated gh in this execution env:\n" +
+    "  - host-gh: run `gh auth login` in this env (host credential store is not shared with sandboxes)\n" +
+    "  - injected-token: set GH_TOKEN / GITHUB_TOKEN / GH_ENTERPRISE_TOKEN and re-probe\n" +
+    "  - Or run SCM-dependent gates from the matched/authenticated env\n" +
+    "  - See content/scm/github.md § Mismatched/headless SCM readiness (#2275)";
+function resolveBinaryPresence(whichFn) {
+    for (const candidate of BINARY_PREFERENCE) {
+        const path = whichFn(candidate);
+        if (path !== null) {
+            return { binary: candidate, binaryPath: path };
+        }
+    }
+    return { binary: null, binaryPath: null };
+}
+/**
+ * Run gh/ghx argv directly (not via scm.call) so readiness probing never
+ * re-enters call() / readiness and cannot mis-route `auth status` (#2275 P1).
+ */
+/**
+ * Prefer live `gh` for auth/status/api probes. ghx is a cached GET proxy
+ * (#884 / #954) and is not a full passthrough for `auth status` / multi-arg
+ * api forms — using it here false-negatives readiness when only ghx is
+ * preferred on PATH.
+ */
+function resolveAuthProbeBinary(whichFn) {
+    return whichFn("gh") ?? whichFn("ghx") ?? "gh";
+}
+function defaultShallowRunGh(args, environ, whichFn = defaultWhich) {
+    const resolved = resolveAuthProbeBinary(whichFn);
+    try {
+        const result = spawnSync(resolved, [...args], {
+            env: environ,
+            encoding: "utf8",
+            timeout: 15_000,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return {
+            args: [resolved, ...args],
+            returncode: result.status ?? 1,
+            stdout: typeof result.stdout === "string" ? result.stdout : "",
+            stderr: typeof result.stderr === "string" ? result.stderr : "",
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            args: [resolved, ...args],
+            returncode: 1,
+            stdout: "",
+            stderr: message,
+        };
+    }
+}
+function mapDeepFailureToAuthState(result) {
+    if (result.ok)
+        return "authenticated";
+    if (result.failureKind === "missing_injected_token")
+        return "missing-token";
+    if (result.failureKind === "gh_auth_failed")
+        return "unauthenticated";
+    if (result.failureKind === "api_unreachable" || result.failureKind === "repo_access_denied") {
+        return "unauthenticated";
+    }
+    return "unknown";
+}
+/**
+ * Probe SCM binary + auth readiness in the current execution environment.
+ *
+ * Never throws. Never echoes token values. Suitable for session:start.
+ */
+export function probeScmReadiness(options = {}) {
+    const env = options.env ?? process.env;
+    const whichFn = options.whichFn ?? defaultWhich;
+    const depth = options.depth ?? "shallow";
+    const runtimeReport = options.runtimeReport ?? probeRuntimeCapabilities(env);
+    const githubAuthMode = options.githubAuthMode ?? inferGithubAuthMode(runtimeReport);
+    const injectedTokenPresent = findInjectedToken(env) !== null;
+    const { binary, binaryPath } = resolveBinaryPresence(whichFn);
+    if (binary === null) {
+        const detail = "gh not found on PATH in this execution env; SCM-dependent gates skipped " +
+            `(runtime_mode=${runtimeReport.runtimeMode}, github_auth_mode=${githubAuthMode})`;
+        return {
+            ready: false,
+            binary: null,
+            binaryPath: null,
+            authState: "binary-absent",
+            githubAuthMode,
+            runtimeMode: runtimeReport.runtimeMode,
+            injectedTokenPresent,
+            depth,
+            detail,
+            remediation: REMEDIATION_BINARY_ABSENT,
+            skippedGates: [...SCM_DEPENDENT_GATES],
+            login: null,
+            failureKind: "binary_absent",
+        };
+    }
+    // Injected-token mode without a token is a hard not-ready even before auth status.
+    if (githubAuthMode === GITHUB_AUTH_MODE_INJECTED_TOKEN && !injectedTokenPresent) {
+        const detail = "injected-token mode requires GH_TOKEN, GITHUB_TOKEN, or GH_ENTERPRISE_TOKEN; " +
+            `binary=${binary} present but SCM-dependent gates skipped ` +
+            `(runtime_mode=${runtimeReport.runtimeMode})`;
+        return {
+            ready: false,
+            binary,
+            binaryPath,
+            authState: "missing-token",
+            githubAuthMode,
+            runtimeMode: runtimeReport.runtimeMode,
+            injectedTokenPresent: false,
+            depth,
+            detail,
+            remediation: REMEDIATION_MISSING_TOKEN,
+            skippedGates: [...SCM_DEPENDENT_GATES],
+            login: null,
+            failureKind: "missing_injected_token",
+        };
+    }
+    if (depth === "deep") {
+        // Prefer live `gh` for auth/API validation — ghx is a cached GET proxy and
+        // rejects multi-arg api forms used by github-auth-modes (#2275 / #954).
+        const deepRunner = options.runGh ??
+            ((args, environ) => {
+                const ghPath = whichFn("gh") ?? binary ?? "gh";
+                try {
+                    const result = spawnSync(ghPath, [...args], {
+                        env: environ,
+                        encoding: "utf8",
+                        timeout: 30_000,
+                        stdio: ["ignore", "pipe", "pipe"],
+                    });
+                    return {
+                        args: [ghPath, ...args],
+                        returncode: result.status ?? 1,
+                        stdout: typeof result.stdout === "string" ? result.stdout : "",
+                        stderr: typeof result.stderr === "string" ? result.stderr : "",
+                    };
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    return { args: [ghPath, ...args], returncode: 1, stdout: "", stderr: message };
+                }
+            });
+        const deep = validateGithubAuthForWorker(githubAuthMode, {
+            environ: env,
+            runtimeReport,
+            repo: options.repo,
+            runGh: deepRunner,
+        });
+        if (deep.ok) {
+            const loginPart = deep.login ? ` as ${deep.login}` : "";
+            return {
+                ready: true,
+                binary,
+                binaryPath,
+                authState: "authenticated",
+                githubAuthMode: deep.githubAuthMode,
+                runtimeMode: runtimeReport.runtimeMode,
+                injectedTokenPresent,
+                depth,
+                detail: `SCM ready: ${binary} present, ${deep.githubAuthMode} authenticated${loginPart} (deep)`,
+                remediation: null,
+                skippedGates: [],
+                login: deep.login,
+                failureKind: null,
+            };
+        }
+        const authState = mapDeepFailureToAuthState(deep);
+        return {
+            ready: false,
+            binary,
+            binaryPath,
+            authState,
+            githubAuthMode: deep.githubAuthMode,
+            runtimeMode: runtimeReport.runtimeMode,
+            injectedTokenPresent,
+            depth,
+            detail: `SCM not ready: ${deep.detail}`,
+            remediation: deep.remediation ?? REMEDIATION_UNAUTHENTICATED,
+            skippedGates: [...SCM_DEPENDENT_GATES],
+            login: deep.login,
+            failureKind: deep.failureKind,
+        };
+    }
+    // Shallow path: optional gh auth status (local credential check, short timeout).
+    const checkAuth = options.checkAuthStatus !== false;
+    if (!checkAuth) {
+        const detail = `SCM binary present (${binary}); auth status not checked (shallow, checkAuthStatus=false); ` +
+            `github_auth_mode=${githubAuthMode}`;
+        return {
+            ready: true,
+            binary,
+            binaryPath,
+            authState: "unknown",
+            githubAuthMode,
+            runtimeMode: runtimeReport.runtimeMode,
+            injectedTokenPresent,
+            depth,
+            detail,
+            remediation: null,
+            skippedGates: [],
+            login: null,
+            failureKind: null,
+        };
+    }
+    const runner = options.runGh ?? ((args, environ) => defaultShallowRunGh(args, environ, whichFn));
+    const authStatus = runner(["auth", "status"], env);
+    if (authStatus.returncode !== 0) {
+        const detail = `gh not authenticated in this execution env (binary=${binary}, ` +
+            `github_auth_mode=${githubAuthMode}); SCM-dependent gates skipped`;
+        return {
+            ready: false,
+            binary,
+            binaryPath,
+            authState: "unauthenticated",
+            githubAuthMode,
+            runtimeMode: runtimeReport.runtimeMode,
+            injectedTokenPresent,
+            depth,
+            detail,
+            remediation: REMEDIATION_UNAUTHENTICATED,
+            skippedGates: [...SCM_DEPENDENT_GATES],
+            login: null,
+            failureKind: "gh_auth_failed",
+        };
+    }
+    return {
+        ready: true,
+        binary,
+        binaryPath,
+        authState: "authenticated",
+        githubAuthMode,
+        runtimeMode: runtimeReport.runtimeMode,
+        injectedTokenPresent,
+        depth,
+        detail: `SCM ready: ${binary} present, ${githubAuthMode} authenticated (shallow)`,
+        remediation: null,
+        skippedGates: [],
+        login: null,
+        failureKind: null,
+    };
+}
+/** JSON-friendly snake_case dict for session:start --json / CLI. */
+export function scmReadinessToDict(report) {
+    return {
+        ready: report.ready,
+        binary: report.binary,
+        binary_path: report.binaryPath,
+        auth_state: report.authState,
+        github_auth_mode: report.githubAuthMode,
+        runtime_mode: report.runtimeMode,
+        injected_token_present: report.injectedTokenPresent,
+        depth: report.depth,
+        detail: report.detail,
+        remediation: report.remediation,
+        skipped_gates: [...report.skippedGates],
+        login: report.login,
+        failure_kind: report.failureKind,
+    };
+}
+/**
+ * Format human lines for session:start (and similar orientation surfaces).
+ * First line is always the one-line status; when not ready, adds skipped gates
+ * and a short remediation pointer.
+ */
+export function formatScmReadinessLines(report) {
+    const lines = [];
+    if (report.ready) {
+        lines.push(`[deft scm] ${report.detail}`);
+        return lines;
+    }
+    lines.push(`[deft scm] ${report.detail}`);
+    if (report.skippedGates.length > 0) {
+        lines.push(`[deft scm] skipped gates: ${report.skippedGates.join(", ")}`);
+    }
+    lines.push("[deft scm] run SCM-dependent gates only after auth is ready, or from a matched env; " +
+        "see content/scm/github.md § Mismatched/headless SCM readiness (#2275)");
+    return lines;
+}
+/**
+ * Fail-loud error for SCM-dependent entry points when readiness is false.
+ * Includes named reason + skipped-gate list so agents never see an opaque failure.
+ */
+export function scmNotReadyError(report) {
+    const r = report ?? probeScmReadiness({ checkAuthStatus: false });
+    if (r.ready && r.binary !== null) {
+        // Caller asked for an error but probe is ready — still surface binary guidance.
+        return new ScmStubError("SCM readiness unexpected: binary present but caller refused; " +
+            "see content/scm/github.md § Mismatched/headless SCM readiness (#2275)");
+    }
+    const gates = r.skippedGates.length > 0 ? ` skipped_gates=[${r.skippedGates.join(", ")}]` : "";
+    return new ScmStubError(`${r.detail}.${gates} Remediation: install gh/ghx and authenticate in this execution env ` +
+        `(host-gh: gh auth login; injected-token: GH_TOKEN/GITHUB_TOKEN), or run SCM gates from a matched env. ` +
+        `Refs #2275.`);
+}
+/**
+ * Assert SCM binary presence for call sites that only need PATH resolution.
+ * Throws ScmStubError with #2275 diagnostic (not the bare "neither ghx nor gh" text alone).
+ */
+export function assertScmBinaryPresent(whichFn = defaultWhich) {
+    const report = probeScmReadiness({
+        whichFn,
+        checkAuthStatus: false,
+        depth: "shallow",
+        // Binary-only assert must not flip to missing-token just because runtime is headless.
+        githubAuthMode: GITHUB_AUTH_MODE_HOST_GH,
+        runtimeReport: getPlatformCapabilities(),
+    });
+    if (report.binary === null) {
+        throw scmNotReadyError(report);
+    }
+    return report.binary;
+}
+/**
+ * Fail-loud gate for SCM-dependent verbs (#2275).
+ * Throws ScmStubError when binary is absent or auth is not ready so agents
+ * never fall through into opaque gh spawn/auth-prompt failures.
+ *
+ * Process-scoped cache: the first successful probe is reused for the rest of
+ * the process so hot call paths do not re-run `gh auth status` every time.
+ * Pass `force: true` to re-probe (tests / after credential injection).
+ */
+let cachedReadyReport = null;
+export function requireScmReady(options = {}) {
+    if (!options.force && cachedReadyReport !== null && cachedReadyReport.ready) {
+        return cachedReadyReport;
+    }
+    // Hermetic unit tests (vitest) and DEFT_SCM_SKIP_AUTH_PROBE only require
+    // binary presence so CI cloud-headless without injected tokens can exercise
+    // CLI argv/REST seams. Production agents get full shallow auth probing.
+    // Session-start / scm:status always report full auth state regardless.
+    const hermeticAuthSkip = options.checkAuthStatus === undefined &&
+        (process.env.VITEST === "true" || process.env.DEFT_SCM_SKIP_AUTH_PROBE === "1");
+    if (hermeticAuthSkip) {
+        // Production path uses assertScmBinaryPresent (not test-only).
+        const binary = assertScmBinaryPresent(options.whichFn);
+        const report = {
+            ready: true,
+            binary,
+            binaryPath: options.whichFn?.(binary) ?? null,
+            authState: "unknown",
+            githubAuthMode: GITHUB_AUTH_MODE_HOST_GH,
+            runtimeMode: (options.runtimeReport ?? getPlatformCapabilities()).runtimeMode,
+            injectedTokenPresent: findInjectedToken(options.env ?? process.env) !== null,
+            depth: "shallow",
+            detail: `SCM binary present (${binary}); auth status not checked (hermetic)`,
+            remediation: null,
+            skippedGates: [],
+            login: null,
+            failureKind: null,
+        };
+        cachedReadyReport = report;
+        return report;
+    }
+    const report = probeScmReadiness({
+        ...options,
+        depth: options.depth ?? "shallow",
+        checkAuthStatus: options.checkAuthStatus ?? true,
+    });
+    if (!report.ready) {
+        throw scmNotReadyError(report);
+    }
+    cachedReadyReport = report;
+    return report;
+}
+/**
+ * Clear the process-scoped readiness cache.
+ * Used by tests and by long-running processes after credential injection.
+ */
+export function clearScmReadyCache() {
+    cachedReadyReport = null;
+}
+export { findInjectedToken, GITHUB_AUTH_MODE_HOST_GH, GITHUB_AUTH_MODE_INJECTED_TOKEN };
+//# sourceMappingURL=readiness.js.map

package/dist/scope/batch-promote.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Batch promote: proposed/ -> pending/ for multi-scope pins (#3011 / epic #3009).
+ *
+ * Keeps one-active-implement intact: this only stages scopes into pending/.
+ * Activate + implement remain one-at-a-time.
+ */
+export interface BatchPromoteOptions {
+    /** Explicit files (absolute or project-relative). Empty = all proposed/ artifacts. */
+    readonly files?: readonly string[];
+    readonly force?: boolean;
+    readonly projectRoot?: string;
+}
+export interface BatchPromoteResult {
+    readonly ok: boolean;
+    readonly promoted: number;
+    readonly skipped: string[];
+    readonly messages: string[];
+    readonly exitCode: number;
+    readonly wipCapOverride?: boolean;
+}
+/**
+ * Promote one or more proposed scopes to pending/, checking WIP once for the
+ * full batch size before any move (#3011).
+ */
+export declare function batchPromote(options?: BatchPromoteOptions): BatchPromoteResult;
+//# sourceMappingURL=batch-promote.d.ts.map

package/dist/scope/batch-promote.js

@@ -0,0 +1,167 @@
+/**
+ * Batch promote: proposed/ -> pending/ for multi-scope pins (#3011 / epic #3009).
+ *
+ * Keeps one-active-implement intact: this only stages scopes into pending/.
+ * Activate + implement remain one-at-a-time.
+ */
+import { existsSync, readdirSync, realpathSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { hasArtifactSuffix, resolveLifecycleFolder } from "../layout/resolve.js";
+import { stripTrailingPathSeparators } from "../text/redos-safe.js";
+import { resolveProjectRoot } from "./project-context.js";
+import { recordWipCapOverride, runTransition } from "./transition.js";
+import { checkWipCapForAdditional, formatWipCapRefusal } from "./wip-cap-check.js";
+/** True when path (and its realpath, if resolvable) stay inside projectRoot. */
+function isPathInsideProject(projectRoot, absPath) {
+    const root = resolve(projectRoot);
+    const abs = resolve(absPath);
+    const rel = relative(root, abs);
+    if (rel === "" || rel.startsWith(`..${sep}`) || rel.startsWith("..") || isAbsolute(rel)) {
+        return false;
+    }
+    // Reject in-project symlinks that resolve outside the tree (#3011 Greptile P1).
+    try {
+        const realRoot = realpathSync(root);
+        const realAbs = realpathSync(abs);
+        const realRel = relative(realRoot, realAbs);
+        if (realRel === "" ||
+            realRel.startsWith(`..${sep}`) ||
+            realRel.startsWith("..") ||
+            isAbsolute(realRel)) {
+            return false;
+        }
+    }
+    catch {
+        // Unreadable realpath — refuse rather than promote through a broken link.
+        return false;
+    }
+    return true;
+}
+/**
+ * Promote one or more proposed scopes to pending/, checking WIP once for the
+ * full batch size before any move (#3011).
+ */
+export function batchPromote(options = {}) {
+    const root = resolveProjectRoot(options.projectRoot);
+    if (root === null) {
+        return {
+            ok: false,
+            promoted: 0,
+            skipped: [],
+            messages: ["Could not resolve project root (pass --project-root)."],
+            exitCode: 2,
+        };
+    }
+    const candidates = resolvePromoteCandidates(root, options.files ?? []);
+    if (candidates.error !== null) {
+        return {
+            ok: false,
+            promoted: 0,
+            skipped: [],
+            messages: [candidates.error],
+            exitCode: 2,
+        };
+    }
+    const files = candidates.files;
+    if (files.length === 0) {
+        return {
+            ok: true,
+            promoted: 0,
+            skipped: [],
+            messages: ["Batch promote: 0 promoted (no proposed/ scopes matched)."],
+            exitCode: 0,
+        };
+    }
+    const capCheck = checkWipCapForAdditional(root, files.length, options.force === true);
+    if (!capCheck.allowed) {
+        return {
+            ok: false,
+            promoted: 0,
+            skipped: [],
+            messages: [
+                formatWipCapRefusal(capCheck) +
+                    `\nBatch promote needs room for ${files.length} additional scope(s); ` +
+                    `current WIP is ${capCheck.count}/${capCheck.cap}.`,
+            ],
+            exitCode: 1,
+        };
+    }
+    const skipped = [];
+    const messages = [];
+    let promoted = 0;
+    for (const filePath of files) {
+        // Re-validate containment immediately before use (TOCTOU: path may become
+        // an out-of-tree symlink after the initial candidate scan) (#3011 P1).
+        if (!isPathInsideProject(root, filePath)) {
+            skipped.push(`${filePath.split(/[/\\]/).pop() ?? filePath}: path escapes project root at promote time`);
+            continue;
+        }
+        const result = runTransition("promote", filePath);
+        if (result.ok) {
+            promoted += 1;
+            messages.push(result.message);
+            if (capCheck.forceOverride) {
+                recordWipCapOverride(filePath, root, capCheck);
+            }
+        }
+        else {
+            skipped.push(`${filePath.split(/[/\\]/).pop() ?? filePath}: ${result.message}`);
+        }
+    }
+    if (capCheck.forceOverride && promoted > 0) {
+        messages.push(`WIP cap exceeded (count_before=${capCheck.count}, cap=${capCheck.cap}, ` +
+            `batch=${files.length}); promote allowed via --force. audit tagged wip_cap_override (#1124/#3011).`);
+    }
+    messages.unshift(`Batch promote: ${promoted} promoted, ${skipped.length} skipped` +
+        (files.length > 0 ? ` (candidates=${files.length})` : "") +
+        ".");
+    return {
+        ok: skipped.length === 0,
+        promoted,
+        skipped,
+        messages,
+        // Partial batch is failure for automation (#3011 Greptile P1).
+        exitCode: skipped.length === 0 ? 0 : 1,
+        wipCapOverride: capCheck.forceOverride && promoted > 0,
+    };
+}
+function resolvePromoteCandidates(projectRoot, explicit) {
+    if (explicit.length > 0) {
+        const resolved = [];
+        for (const raw of explicit) {
+            const stripped = stripTrailingPathSeparators(raw.trim());
+            if (stripped.length === 0) {
+                continue;
+            }
+            const abs = isAbsolute(stripped) ? resolve(stripped) : resolve(projectRoot, stripped);
+            if (!existsSync(abs)) {
+                return { files: [], error: `File not found: ${abs}` };
+            }
+            if (!isPathInsideProject(projectRoot, abs)) {
+                return {
+                    files: [],
+                    error: `Path escapes project root (refusing out-of-tree scope): ${abs}`,
+                };
+            }
+            const base = abs.split(/[/\\]/).pop() ?? "";
+            if (!hasArtifactSuffix(base)) {
+                return {
+                    files: [],
+                    error: `Not a vBRIEF file (expected .vbrief.json or .xbrief.json): ${base}`,
+                };
+            }
+            resolved.push(abs);
+        }
+        return { files: resolved, error: null };
+    }
+    const proposedDir = resolveLifecycleFolder(projectRoot, "proposed");
+    if (!existsSync(proposedDir)) {
+        return { files: [], error: null };
+    }
+    const files = readdirSync(proposedDir)
+        .filter((name) => hasArtifactSuffix(name))
+        .sort()
+        .map((name) => join(proposedDir, name));
+    return { files, error: null };
+}
+//# sourceMappingURL=batch-promote.js.map

package/dist/scope/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./audit-log.js";
+export * from "./batch-promote.js";
 export * from "./constants.js";
 export * from "./decomposed-refs.js";
 export * from "./demote.js";

package/dist/scope/index.js

@@ -1,4 +1,5 @@
 export * from "./audit-log.js";
+export * from "./batch-promote.js";
 export * from "./constants.js";
 export * from "./decomposed-refs.js";
 export * from "./demote.js";

package/dist/scope/main.d.ts

@@ -3,6 +3,8 @@ export interface LifecycleArgs {
     file: string;
     projectRoot?: string;
     force?: boolean;
+    batch?: boolean;
+    batchFiles?: string[];
 }
 export interface DemoteArgs {
     file?: string;