@deftai/directive-core 0.88.0 → 0.90.0

package/dist/policy/write-fence.js

@@ -0,0 +1,164 @@
+/**
+ * Unified path write fence (#516 / #2443 / #2948 Wave 3).
+ *
+ * Single evaluation SoT: path checks always go through
+ * `evaluateRuntimeAuthorityPath` / `evaluateRuntimeAuthorityDirectWrite`.
+ * This module only **resolves** a RuntimeAuthorityPolicy by intersecting
+ * project `runtimeAuthority.allowPaths` / `denyPaths` with optional story
+ * `plan.metadata.swarm.file_scope` (and a read-time `writeScope` alias).
+ *
+ * There is no second independent writeScope evaluation engine.
+ */
+import { readFileSync } from "node:fs";
+import { DEFAULT_RUNTIME_AUTHORITY_POLICY, DEFAULT_RUNTIME_AUTHORITY_SCOPES, } from "./runtime-authority.js";
+/** Clean non-empty path glob strings. */
+function cleanGlobs(raw) {
+    if (raw === null || raw === undefined)
+        return [];
+    return raw.filter((s) => typeof s === "string" && s.trim().length > 0);
+}
+function cleanGlobArray(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((s) => typeof s === "string" && s.trim().length > 0);
+}
+/**
+ * Normalize a legacy #2443 `writeScope` alias into `file_scope` + deny globs.
+ * Accepts:
+ * - `string[]` → allow list
+ * - `{ allow?: string[], deny?: string[] }`
+ * - `{ file_scope?: string[], denyPaths?: string[] }` (already-normalized shape)
+ *
+ * Callers MUST feed the result into {@link resolveWriteFence}; do not evaluate
+ * writeScope with a separate matcher.
+ */
+export function normalizeStoryWriteScope(raw) {
+    if (raw === null || raw === undefined) {
+        return { fileScope: [], denyPaths: [] };
+    }
+    if (Array.isArray(raw)) {
+        return { fileScope: cleanGlobArray(raw), denyPaths: [] };
+    }
+    if (typeof raw !== "object") {
+        return { fileScope: [], denyPaths: [] };
+    }
+    const rec = raw;
+    const allow = cleanGlobArray(rec.allow ?? rec.file_scope ?? rec.fileScope);
+    const deny = cleanGlobArray(rec.deny ?? rec.denyPaths);
+    return { fileScope: allow, denyPaths: deny };
+}
+/**
+ * Extract story write fence from an xBRIEF/vBRIEF document.
+ * Prefer `plan.metadata.swarm.file_scope`; fall back to normalized `writeScope`
+ * on `plan.metadata.swarm` or `plan.metadata` (read-time alias only).
+ */
+export function extractStoryFileScope(storyData) {
+    if (typeof storyData !== "object" || storyData === null || Array.isArray(storyData)) {
+        return { fileScope: [], denyPaths: [] };
+    }
+    const plan = storyData.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return { fileScope: [], denyPaths: [] };
+    }
+    const metadata = plan.metadata;
+    if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) {
+        return { fileScope: [], denyPaths: [] };
+    }
+    const meta = metadata;
+    const swarmRaw = meta.swarm;
+    const swarm = typeof swarmRaw === "object" && swarmRaw !== null && !Array.isArray(swarmRaw)
+        ? swarmRaw
+        : null;
+    const fromFileScope = cleanGlobArray(swarm?.file_scope ?? swarm?.fileScope);
+    const fromWriteScope = normalizeStoryWriteScope(swarm?.writeScope ?? swarm?.write_scope ?? meta.writeScope ?? meta.write_scope);
+    // file_scope is SoT when present; writeScope alias only when file_scope empty.
+    if (fromFileScope.length > 0) {
+        // Still merge writeScope.deny so legacy deny lists are not lost.
+        return {
+            fileScope: fromFileScope,
+            denyPaths: fromWriteScope.denyPaths,
+        };
+    }
+    return fromWriteScope;
+}
+/** Load story fence from an active xBRIEF path (fail-open on IO/parse errors). */
+export function loadStoryWriteFenceFromPath(scopePath) {
+    if (scopePath === null || scopePath === undefined || scopePath.trim().length === 0) {
+        return { fileScope: [], denyPaths: [] };
+    }
+    try {
+        const text = readFileSync(scopePath, "utf8");
+        const data = JSON.parse(text);
+        return extractStoryFileScope(data);
+    }
+    catch {
+        // Residual: host/session may not surface a readable active story.
+        // Fail open at story layer (project policy still applies if enabled).
+        return { fileScope: [], denyPaths: [] };
+    }
+}
+/**
+ * Intersect project `runtimeAuthority` with optional story `file_scope`.
+ *
+ * Rules:
+ * - Empty project `allowPaths` when enabled = all paths until story narrows.
+ * - Empty story scope = project policy only.
+ * - Story `file_scope` alone enables a fence even when project policy is disabled.
+ * - `denyPaths` always win (project + story-normalized denys).
+ * - When both project allowPaths and story file_scope are non-empty, a path must
+ *   match **both** layers (AND / intersection semantics via dual allow layers).
+ */
+export function resolveWriteFence(projectPolicy, storyFileScope, options) {
+    const storyAllow = cleanGlobs(storyFileScope);
+    const storyDeny = cleanGlobs(options?.storyDenyPaths);
+    const projectActive = projectPolicy.enabled;
+    const storyActive = storyAllow.length > 0 || storyDeny.length > 0;
+    if (!projectActive && !storyActive) {
+        return {
+            policy: DEFAULT_RUNTIME_AUTHORITY_POLICY,
+            sources: [],
+            fenceActive: false,
+            storyAllowPaths: [],
+            storyDenyPaths: [],
+        };
+    }
+    const sources = [];
+    if (projectActive)
+        sources.push("project");
+    if (storyActive)
+        sources.push("story");
+    // Project denyPaths + story denyPaths; deny always wins at evaluation time.
+    const denyPaths = [...projectPolicy.denyPaths, ...storyDeny];
+    // Project allow layer only when project policy is enabled (empty = unrestricted until story).
+    const allowPaths = projectActive ? [...projectPolicy.allowPaths] : [];
+    // Story-only: enable fence with default scopes (edits true) so direct writes are gated.
+    const scopes = projectActive
+        ? projectPolicy.scopes
+        : { ...DEFAULT_RUNTIME_AUTHORITY_SCOPES, edits: true };
+    const policy = {
+        enabled: true,
+        allowPaths,
+        denyPaths,
+        scopes,
+        storyAllowPaths: storyAllow,
+        fenceSources: sources,
+    };
+    return {
+        policy,
+        sources,
+        fenceActive: true,
+        storyAllowPaths: storyAllow,
+        storyDenyPaths: storyDeny,
+    };
+}
+/**
+ * Resolve the write fence for PreToolUse / product sinks.
+ * Composes project policy with story fence extracted from an active xBRIEF path.
+ */
+export function resolveWriteFenceForScope(projectPolicy, scopePath, loadStory = loadStoryWriteFenceFromPath) {
+    const story = loadStory(scopePath);
+    return resolveWriteFence(projectPolicy, story.fileScope, {
+        storyDenyPaths: story.denyPaths,
+    });
+}
+//# sourceMappingURL=write-fence.js.map

package/dist/pr-wait-mergeable/cascade.d.ts

@@ -1,3 +1,4 @@
+import { type AgentMergeEvaluateResult } from "../policy/require-human-merge.js";
 import { type SemanticGreenFn } from "./semantic-green.js";
 import type { MergeFn, MonitorFn, ProtectedCheckFn, WaitMergeableResult } from "./types.js";
 export interface WaitMergeableOptions {
@@ -11,6 +12,15 @@ export interface WaitMergeableOptions {
     readonly requireMasterCiGreen?: boolean;
     /** Target branch override for stale-base comparison (defaults to PR base.ref). */
     readonly baseBranch?: string | null;
+    /**
+     * Project root for human-merge + intent-ceiling preflight (#1193).
+     * Defaults to process.cwd(). Pass explicitly in tests.
+     */
+    readonly projectRoot?: string;
+    /** Inject agent-merge evaluator (unit tests). */
+    readonly agentMergeFn?: (projectRoot: string) => AgentMergeEvaluateResult;
+    /** When true, skip human-merge / intent preflight (tests only). */
+    readonly skipHumanMergeGate?: boolean;
 }
 /** Run protected-check -> wait -> merge cascade (#1369). */
 export declare function waitMergeableAndMerge(prNumber: number, repo: string, options: {

package/dist/pr-wait-mergeable/cascade.js

@@ -1,3 +1,5 @@
+import { evaluateIntentCeilingFromEnv } from "../policy/intent-ceiling.js";
+import { evaluateAgentMerge, } from "../policy/require-human-merge.js";
 import { classifyMonitorOutcome, parseMonitorPayload } from "./classify.js";
 import { EXIT_CONFIG_ERROR, EXIT_MERGED, EXIT_TIMEOUT_OR_ESCALATION } from "./constants.js";
 import { makeResult } from "./result.js";
@@ -17,6 +19,32 @@ export function waitMergeableAndMerge(prNumber, repo, options) {
     const mergeFn = options.mergeFn ?? runGhMerge;
     const semanticGreenFn = options.semanticGreenFn ?? evaluateSemanticGreen;
     const protectedIssues = options.protected;
+    const projectRoot = options.projectRoot ?? process.cwd();
+    // #1193 surface (1): refuse agent merge when requireHumanMerge is true,
+    // and refuse when slash-command intent ceiling does not authorize merge.
+    if (options.skipHumanMergeGate !== true) {
+        const intent = evaluateIntentCeilingFromEnv("merge");
+        if (!intent.allowed) {
+            return makeResult({
+                prNumber,
+                repo,
+                outcome: "config-error",
+                exitCode: EXIT_CONFIG_ERROR,
+                error: intent.reason,
+            });
+        }
+        const agentMergeFn = options.agentMergeFn ?? evaluateAgentMerge;
+        const hm = agentMergeFn(projectRoot);
+        if (!hm.allowed) {
+            return makeResult({
+                prNumber,
+                repo,
+                outcome: "config-error",
+                exitCode: EXIT_CONFIG_ERROR,
+                error: hm.message,
+            });
+        }
+    }
     let protectedCheckPayload = {};
     if (protectedIssues.length > 0) {
         const [prcRc, prcStdout, prcStderr] = protectedFn(prNumber, repo, protectedIssues);

package/dist/preflight/evaluate.js

@@ -1,5 +1,6 @@
 import { readFileSync, statSync } from "node:fs";
 import { basename, dirname } from "node:path";
+import { evaluateIntentCeilingFromEnv } from "../policy/intent-ceiling.js";
 /** Canonical eligibility folder — only vbrief/active/ may spawn implementation. */
 export const ACTIVE_FOLDER = "active";
 /** Canonical eligibility status — only `running` signals an active handoff. */
@@ -124,6 +125,15 @@ export function evaluate(vbriefPath) {
             message: buildReject(path, `plan.status is '${status}' -- only '${ELIGIBLE_STATUS}' is eligible for implementation.`),
         };
     }
+    // Slash-command intent containment (#1193 / extends #810): non-implement session
+    // verbs must not authorize implementation preflight even when the xBRIEF is active.
+    const intent = evaluateIntentCeilingFromEnv("implement");
+    if (!intent.allowed) {
+        return {
+            exitCode: 1,
+            message: buildReject(path, intent.reason),
+        };
+    }
     return {
         exitCode: 0,
         message: `OK ${path} -- ready for implementation.`,

package/dist/product-signal/consent.js

@@ -1,6 +1,7 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
 import { DEFAULT_PRODUCT_SIGNAL_SINK_REPO } from "../policy/product-signal.js";
 import { platformUserConfigDir } from "../user-config/resolve-user-md.js";
 export const PRODUCT_SIGNAL_CONSENT_FILENAME = "product-signal-consent.json";
@@ -142,8 +143,15 @@ export function grantProductSignalConsent(options = {}) {
         sinkRepo,
     };
     const path = resolveProductSignalConsentPath(options);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+    // #2980 wave D: product write sink routes through containedWrite.
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    containedWrite({
+        root: resolve(dir),
+        target: basename(path),
+        data: `${JSON.stringify(record, null, 2)}\n`,
+        mode: "replace",
+    });
     return record;
 }
 /** Revoke consent by setting revokedAt (#2693 D2). */
@@ -167,7 +175,15 @@ export function revokeProductSignalConsent(options = {}) {
         ...existing,
         revokedAt: now.toISOString().replace(/\.\d{3}Z$/, "Z"),
     };
-    writeFileSync(path, `${JSON.stringify(revoked, null, 2)}\n`, "utf8");
+    // #2980 wave D: product write sink routes through containedWrite.
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    containedWrite({
+        root: resolve(dir),
+        target: basename(path),
+        data: `${JSON.stringify(revoked, null, 2)}\n`,
+        mode: "replace",
+    });
     return true;
 }
 //# sourceMappingURL=consent.js.map

package/dist/product-signal/submit.js

@@ -1,6 +1,7 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
+import { ContainedWriteError, containedWrite } from "../fs/contained-write.js";
+import { ProjectionContainmentError } from "../fs/projection-containment.js";
 import { enableProductSignal, formatProductSignalStatusLine, resolveProductSignal, } from "../policy/product-signal.js";
 import { resolveProjectRoot } from "../scope/project-context.js";
 import { resolveActorName } from "./actor-name.js";
@@ -15,17 +16,26 @@ import { bootstrapProductSignalSink } from "./sink-bootstrap.js";
 export const PRODUCT_SIGNAL_LAST_SUBMIT_REL = join(".deft-cache", "product-signal-last-submit.json");
 function recordLastSubmit(projectRoot, outcome, url) {
     const path = resolve(projectRoot, PRODUCT_SIGNAL_LAST_SUBMIT_REL);
-    assertWriteTargetSafe(projectRoot, path);
     try {
-        mkdirSync(join(path, ".."), { recursive: true });
-        appendFileSync(path, `${JSON.stringify({
-            outcome,
-            issueUrl: url,
-            at: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
-        })}\n`, "utf8");
+        // #2980 wave D: product write sink routes through containedWrite.
+        const root = resolve(projectRoot);
+        containedWrite({
+            root,
+            target: path,
+            data: `${JSON.stringify({
+                outcome,
+                issueUrl: url,
+                at: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
+            })}\n`,
+            mode: "append",
+        });
     }
-    catch {
-        // observability only
+    catch (err) {
+        // Containment refusals must fail closed (tests + product path) (#2807 / #2980).
+        if (err instanceof ContainedWriteError || err instanceof ProjectionContainmentError) {
+            throw err;
+        }
+        // other observability I/O failures only
     }
 }
 function readLastSubmitSummary(projectRoot) {
@@ -134,7 +144,7 @@ export async function submitProductSignal(options) {
             recordLastSubmit(root, result.outcome, result.issueUrl ?? null);
         }
         catch (err) {
-            if (err instanceof ProjectionContainmentError) {
+            if (err instanceof ProjectionContainmentError || err instanceof ContainedWriteError) {
                 return {
                     outcome: "error-config",
                     exitCode: 2,

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

@@ -1,8 +1,10 @@
 /**
  * Subprocess entry for sync callers (release pipeline, task build).
  * Top-level await keeps the process alive until the archive is written.
+ * Progress ticks go to stderr so pipeline callers can still capture the
+ * archive path on stdout (#2953).
  */
-import { buildArchive, selectFormat } from "./build-dist.js";
+import { buildArchive, emitBuildProgress, selectFormat } from "./build-dist.js";
 const version = process.argv[2];
 const root = process.argv[3];
 if (!version || !root) {
@@ -11,7 +13,8 @@ if (!version || !root) {
 }
 const fmt = selectFormat(process.env.DEFT_BUILD_FORMAT);
 try {
-    const out = await buildArchive(root, version, fmt);
+    process.stderr.write(`build-dist-runner: start version=${version} format=${fmt}\n`);
+    const out = await buildArchive(root, version, fmt, { onProgress: emitBuildProgress });
     process.stdout.write(`${out}\n`);
 }
 catch (err) {

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

@@ -8,7 +8,25 @@ export declare function iterSourceFiles(root: string, excludes?: ReadonlySet<str
 }>;
 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 type BuildProgress = {
+    readonly stage: string;
+    readonly detail?: string;
+    readonly current?: number;
+    readonly total?: number;
+};
+export type BuildArchiveOptions = {
+    readonly extraExcludes?: readonly string[];
+    /** Progress sink; default silent so unit tests stay quiet (#2953). */
+    readonly onProgress?: (p: BuildProgress) => void;
+};
+/**
+ * Emit human-readable stage progress for long release packaging runs (#2953).
+ * Writes to stderr so stdout stays the archive path for pipeline capture.
+ */
+export declare function emitBuildProgress(progress: BuildProgress, stream?: {
+    write: (chunk: string) => unknown;
+}): void;
+export declare function buildArchive(root: string, version: string, fmt: "tar" | "zip", options?: readonly string[] | BuildArchiveOptions): 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

@@ -16,6 +16,9 @@ export const DEFAULT_EXCLUDES = new Set([
     ".ruff_cache",
     ".coverage",
     "coverage",
+    // Scratch worktrees are never shippable framework content (#2953).
+    ".deft-scratch",
+    "swarm-worktrees",
 ]);
 export const DEFAULT_EXCLUDED_PATH_PREFIXES = [
     "history/archive",
@@ -97,14 +100,46 @@ 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 = []) {
+/**
+ * Emit human-readable stage progress for long release packaging runs (#2953).
+ * Writes to stderr so stdout stays the archive path for pipeline capture.
+ */
+export function emitBuildProgress(progress, stream = process.stderr) {
+    const { stage, detail, current, total } = progress;
+    let line = `build-dist: ${stage}`;
+    if (typeof current === "number" && typeof total === "number" && total > 0) {
+        const pct = Math.min(100, Math.floor((current / total) * 100));
+        line += ` ${current}/${total} (${pct}%)`;
+    }
+    if (detail)
+        line += ` - ${detail}`;
+    stream.write(`${line}\n`);
+}
+function isExtraExcludesList(options) {
+    return Array.isArray(options);
+}
+function resolveBuildOptions(options = {}) {
+    // Backward-compatible: 4th arg may be a bare extra-excludes array (pre-#2953).
+    if (isExtraExcludesList(options)) {
+        return { extraExcludes: options, onProgress: () => { } };
+    }
+    return {
+        extraExcludes: options.extraExcludes ?? [],
+        onProgress: options.onProgress ?? (() => { }),
+    };
+}
+export async function buildArchive(root, version, fmt, options = {}) {
+    const { extraExcludes, onProgress } = resolveBuildOptions(options);
     const excludes = new Set([...DEFAULT_EXCLUDES, ...extraExcludes]);
     const output = outputPath(root, version, fmt);
     mkdirSync(dirname(output), { recursive: true });
     if (existsSync(output)) {
         unlinkSync(output);
     }
+    onProgress({ stage: "scan", detail: "enumerating source files" });
     const entries = iterSourceFiles(root, excludes);
+    const total = entries.length;
+    onProgress({ stage: "scan", detail: `found ${total} files`, current: total, total });
     await new Promise((resolvePromise, reject) => {
         const out = createWriteStream(output);
         const archive = fmt === "zip"
@@ -114,11 +149,21 @@ export async function buildArchive(root, version, fmt, extraExcludes = []) {
         out.on("error", (err) => reject(err));
         archive.on("error", (err) => reject(err));
         archive.pipe(out);
+        onProgress({ stage: "pack", detail: `format=${fmt}`, current: 0, total });
+        // Progress ticks every ~5% (or every 250 files) so long packs do not look hung.
+        const tickEvery = Math.max(1, Math.min(250, Math.ceil(total / 20)));
+        let i = 0;
         for (const { absPath, archiveRel } of entries) {
             archive.file(absPath, { name: `${ARCHIVE_ROOT}/${archiveRel}` });
+            i += 1;
+            if (i === total || i % tickEvery === 0) {
+                onProgress({ stage: "pack", current: i, total });
+            }
         }
+        onProgress({ stage: "finalize", detail: output });
         void archive.finalize();
     });
+    onProgress({ stage: "done", detail: output, current: total, total });
     return output;
 }
 export function parseExtraExcludes(raw) {
@@ -159,7 +204,10 @@ export async function main(argv) {
     }
     const fmt = selectFormat(fmtArg);
     try {
-        const out = await buildArchive(projectRoot, version, fmt, parseExtraExcludes(extra));
+        const out = await buildArchive(projectRoot, version, fmt, {
+            extraExcludes: parseExtraExcludes(extra),
+            onProgress: emitBuildProgress,
+        });
         const printable = relative(projectRoot, out) || out;
         process.stdout.write(`Created ${printable}\n`);
         return 0;

package/dist/release/native-steps.js

@@ -79,16 +79,21 @@ export function runBuildNative(projectRoot, version, _seams = {}) {
         return [false, "build requires a release version"];
     }
     const env = { ...process.env, DEFT_RELEASE_VERSION: version };
+    // Inherit stderr so build-dist-runner progress ticks stream live during
+    // release Step 8; capture stdout only for the archive path (#2953).
     const result = spawnSync(process.execPath, [BUILD_DIST_RUNNER, version, projectRoot], {
         cwd: projectRoot,
         encoding: "utf8",
         env,
+        stdio: ["ignore", "pipe", "inherit"],
     });
     if (result.status !== 0) {
-        const msg = (result.stderr ?? result.stdout ?? "").trim() || `exit ${result.status ?? 1}`;
+        const captured = (typeof result.stderr === "string" ? result.stderr : "") ||
+            (typeof result.stdout === "string" ? result.stdout : "");
+        const msg = captured.trim() || `exit ${result.status ?? 1}`;
         return [false, `build failed: ${msg}`];
     }
-    const out = (result.stdout ?? "").trim();
+    const out = (typeof result.stdout === "string" ? result.stdout : "").trim();
     return [true, `build ran clean (DEFT_RELEASE_VERSION=${version}) -> ${out}`];
 }
 //# sourceMappingURL=native-steps.js.map

package/dist/release/spawn.js

@@ -24,6 +24,19 @@ export function spawnText(cmd, args, options = {}) {
     if (status === null) {
         if (result.signal !== null && result.signal !== undefined) {
             status = 128;
+            // Timeout kills leave stderr empty; surface timeout so e2e never reports
+            // "failed: " with a blank reason (#3004 / #1867).
+            if (stderr.trim().length === 0) {
+                if (result.error) {
+                    stderr = result.error.message;
+                }
+                else if (options.timeoutMs !== undefined) {
+                    stderr = `process terminated by signal ${result.signal} (timeout ${options.timeoutMs}ms)`;
+                }
+                else {
+                    stderr = `process terminated by signal ${result.signal}`;
+                }
+            }
         }
         else if (result.error) {
             status = 2;

package/dist/release-e2e/git-ops.d.ts

@@ -1,4 +1,11 @@
+import type { SpawnResult } from "../release/types.js";
 import type { E2ESeams } from "./types.js";
+/** Mirror push can exceed the generic release `runGit` 30s cap (#3004). Align with clone. */
+export declare const PUSH_MIRROR_TIMEOUT_MS = 300000;
+/** Prefer stderr; never leave a blank reason after "failed:" (#3004). */
+export declare function formatGitOpFailure(op: string, result: SpawnResult, options?: {
+    timeoutMs?: number;
+}): string;
 export declare function cloneRepoToTemp(projectRoot: string, targetDir: string, seams?: E2ESeams): [boolean, string];
 export declare function setOriginToTempRepo(cloneDir: string, owner: string, slug: string, seams?: E2ESeams): [boolean, string];
 export declare function pushMirror(cloneDir: string, seams?: E2ESeams): [boolean, string];

package/dist/release-e2e/git-ops.js

@@ -1,11 +1,22 @@
 import { runGit as releaseRunGit } from "../release/git.js";
 import { spawnText } from "../release/spawn.js";
+/** Mirror push can exceed the generic release `runGit` 30s cap (#3004). Align with clone. */
+export const PUSH_MIRROR_TIMEOUT_MS = 300_000;
 function defaultRunGit(projectRoot, args, env, seams = {}) {
     if (seams.runGit) {
         return seams.runGit(projectRoot, args, env);
     }
     return releaseRunGit(projectRoot, args, { spawnText: seams.spawnText ?? spawnText }, env);
 }
+/** Prefer stderr; never leave a blank reason after "failed:" (#3004). */
+export function formatGitOpFailure(op, result, options = {}) {
+    const stderr = result.stderr.trim();
+    if (stderr.length > 0) {
+        return `${op} failed: ${stderr}`;
+    }
+    const timeoutHint = options.timeoutMs !== undefined ? `; possible timeout after ${options.timeoutMs}ms` : "";
+    return `${op} failed: no stderr (exit ${result.status ?? "null"}${timeoutHint})`;
+}
 export function cloneRepoToTemp(projectRoot, targetDir, seams = {}) {
     const env = { ...process.env, DEFT_PROJECT_ROOT: targetDir };
     const spawn = seams.spawnText ?? spawnText;
@@ -27,9 +38,31 @@ export function setOriginToTempRepo(cloneDir, owner, slug, seams = {}) {
     return [true, `origin -> ${url}`];
 }
 export function pushMirror(cloneDir, seams = {}) {
-    const result = defaultRunGit(cloneDir, ["push", "origin", "refs/heads/*:refs/heads/*", "refs/tags/*:refs/tags/*"], undefined, seams);
+    // Do not use default release runGit (30s) — full heads+tags mirror of directive
+    // routinely exceeds that on first push to an empty temp repo (#3004).
+    const pushArgs = [
+        "push",
+        "origin",
+        "refs/heads/*:refs/heads/*",
+        "refs/tags/*:refs/tags/*",
+    ];
+    let result;
+    if (seams.runGit) {
+        result = seams.runGit(cloneDir, [...pushArgs], undefined);
+    }
+    else {
+        const spawn = seams.spawnText ?? spawnText;
+        result = spawn("git", ["-C", cloneDir, ...pushArgs], {
+            timeoutMs: PUSH_MIRROR_TIMEOUT_MS,
+        });
+    }
     if (result.status !== 0) {
-        return [false, `git push (heads+tags refspecs) failed: ${result.stderr.trim()}`];
+        return [
+            false,
+            formatGitOpFailure("git push (heads+tags refspecs)", result, {
+                timeoutMs: PUSH_MIRROR_TIMEOUT_MS,
+            }),
+        ];
     }
     return [true, "pushed heads + tags to temp origin"];
 }

package/dist/release-publish/pipeline.d.ts

@@ -1,4 +1,17 @@
+import { type EnvMap } from "../authz/closed-verb.js";
+import type { ClosedVerbDecision, HumanOriginGrant } from "../authz/types.js";
 import type { PublishConfig, ReleasePublishSeams } from "./types.js";
 export declare function emit(label: string, status: string): void;
+/**
+ * Fail-closed gate before draft→public (#1095 Wave 4).
+ * Allow only DEFT_ALLOW_RELEASE_PUBLISH=1 or a matching human-origin grant.
+ * Loads conventions/verb-classification.json from projectRoot when present.
+ * Test seam: pass grants / env via optional overrides on seams when present.
+ */
+export declare function evaluateReleasePublishGate(version: string, projectRoot: string, options?: {
+    readonly grants?: readonly HumanOriginGrant[];
+    readonly env?: EnvMap;
+    readonly repo?: string | null;
+}): ClosedVerbDecision;
 export declare function runPublish(config: PublishConfig, seams?: ReleasePublishSeams): number;
 //# sourceMappingURL=pipeline.d.ts.map