@deftai/directive-core 0.73.1 → 0.75.0

package/dist/fs/projection-containment.js

@@ -0,0 +1,118 @@
+/**
+ * projection-containment.ts — repo-controlled projection symlink guard (#2413).
+ *
+ * Projection writers (`codebase:map`, `triage:bootstrap`) write to well-known
+ * paths such as `.planning/codebase/MAP.md`, `.gitignore`, and `.gitattributes`.
+ * If a malicious repo author commits one of those paths (or a parent) as a
+ * symlink escaping the project tree, routine operator commands would follow the
+ * link and create/overwrite files outside the checkout.
+ *
+ * `assertProjectionContained` anchors on `realpath(projectDir)`, walks each
+ * existing component down to the write target, rejects symlinks that escape the
+ * tree, and asserts the deepest existing ancestor stays under the project root.
+ *
+ * Refs #2413.
+ */
+import { lstatSync, realpathSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+/** Non-zero exit code for a projection-containment refusal (needs-action). */
+export const PROJECTION_CONTAINMENT_REFUSED_EXIT_CODE = 2;
+/** Thrown when a projection write target escapes the project tree. */
+export class ProjectionContainmentError extends Error {
+    projectDir;
+    targetPath;
+    offendingPath;
+    constructor(message, details) {
+        super(message);
+        this.name = "ProjectionContainmentError";
+        this.projectDir = details.projectDir;
+        this.targetPath = details.targetPath;
+        this.offendingPath = details.offendingPath;
+    }
+}
+/**
+ * Path-SEGMENT containment: is `child` equal to `parent` or nested under it?
+ * Uses `path.relative` so `/foo` is NOT treated as containing `/foobar`.
+ */
+function isContained(parent, child) {
+    if (parent === child) {
+        return true;
+    }
+    const rel = relative(parent, child);
+    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel);
+}
+/**
+ * Refuse projection writes when the target (or a parent) is a symlink that
+ * escapes the resolved project tree. Throws {@link ProjectionContainmentError};
+ * MUST be called BEFORE any projection read/write/mkdir.
+ */
+export function assertProjectionContained(projectDir, targetPath) {
+    const projectAbs = resolve(projectDir);
+    let projectReal;
+    try {
+        projectReal = realpathSync(projectAbs);
+    }
+    catch {
+        throw new ProjectionContainmentError(`projection write refused: project directory ${projectAbs} does not exist`, { projectDir: projectAbs, targetPath: resolve(targetPath), offendingPath: projectAbs });
+    }
+    const targetAbs = resolve(targetPath);
+    const rel = relative(projectAbs, targetAbs);
+    if (rel.length === 0 || rel.startsWith("..") || isAbsolute(rel)) {
+        throw new ProjectionContainmentError(`projection write refused: target ${targetAbs} is not nested under the project tree ${projectAbs}`, { projectDir: projectAbs, targetPath: targetAbs, offendingPath: targetAbs });
+    }
+    const segments = rel.split(/[\\/]+/).filter((segment) => segment.length > 0);
+    let current = projectAbs;
+    let deepestExistingReal = projectReal;
+    for (const segment of segments) {
+        current = join(current, segment);
+        let info;
+        try {
+            info = lstatSync(current);
+        }
+        catch {
+            break;
+        }
+        if (info.isSymbolicLink()) {
+            let linkReal;
+            try {
+                linkReal = realpathSync(current);
+            }
+            catch {
+                throw new ProjectionContainmentError(`projection write refused: ${current} is a broken/dangling symlink on the projection path`, { projectDir: projectAbs, targetPath: targetAbs, offendingPath: current });
+            }
+            if (!isContained(projectReal, linkReal)) {
+                throw new ProjectionContainmentError(`projection write refused: ${current} is a symlink escaping the project tree ` +
+                    `(resolves to ${linkReal}, outside ${projectReal})`, { projectDir: projectAbs, targetPath: targetAbs, offendingPath: current });
+            }
+            deepestExistingReal = linkReal;
+            current = linkReal;
+        }
+        else {
+            try {
+                deepestExistingReal = realpathSync(current);
+            }
+            catch (err) {
+                throw new ProjectionContainmentError(`projection write refused: could not resolve ${current} on the projection path`, { projectDir: projectAbs, targetPath: targetAbs, offendingPath: current });
+            }
+        }
+    }
+    try {
+        const targetReal = realpathSync(targetAbs);
+        if (!isContained(projectReal, targetReal)) {
+            throw new ProjectionContainmentError(`projection write refused: projection target resolves outside the project tree ` +
+                `(${targetReal} is outside ${projectReal})`, { projectDir: projectAbs, targetPath: targetAbs, offendingPath: targetReal });
+        }
+        deepestExistingReal = targetReal;
+    }
+    catch (err) {
+        if (err instanceof ProjectionContainmentError) {
+            throw err;
+        }
+        // Target does not exist yet; parent walk above is sufficient.
+    }
+    if (!isContained(projectReal, deepestExistingReal)) {
+        throw new ProjectionContainmentError(`projection write refused: projection path escapes the project tree ` +
+            `(${deepestExistingReal} is outside ${projectReal})`, { projectDir: projectAbs, targetPath: targetAbs, offendingPath: deepestExistingReal });
+    }
+}
+//# sourceMappingURL=projection-containment.js.map

package/dist/init-deposit/scaffold.d.ts

@@ -61,6 +61,27 @@ export interface GitHooksSeams {
     setHooksPath?: (projectDir: string, value: string) => boolean;
 }
 export declare function writeConsumerGitHooks(projectDir: string, deftDir: string, io: InitDepositIo, seams?: GitHooksSeams): boolean;
+/** Commit SHA for `actions/checkout` deposited in deft-core-guard.yml (#1672 / #1072). */
+export declare const CORE_GUARD_CHECKOUT_SHA = "9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0";
+/** Tag comment paired with {@link CORE_GUARD_CHECKOUT_SHA}. */
+export declare const CORE_GUARD_CHECKOUT_TAG = "v7.0.0";
+/**
+ * Extract the `uses: actions/checkout@…` step line from a guard workflow, if present.
+ * Uses linear string scanning (no regex) to avoid CodeQL js/polynomial-redos (#1672).
+ */
+export declare function extractCoreGuardCheckoutUsesLine(content: string): string | null;
+/**
+ * Whether refresh should keep the existing checkout pin instead of the template pin.
+ * Legacy framework-deposited `@v4` tags migrate forward; consumer/Dependabot bumps do not.
+ */
+export declare function shouldPreserveCoreGuardCheckoutPin(existingUsesLine: string, desiredUsesLine: string): boolean;
+/** Canonical SHA-pinned checkout step for the deposited deft-core-guard workflow. */
+export declare function coreGuardCheckoutUsesLine(sha?: string, tag?: string): string;
+/**
+ * On refresh, preserve an existing consumer `actions/checkout@…` pin while updating
+ * the managed guard script / allowlist body (#1672 option 1).
+ */
+export declare function mergeCoreGuardWorkflowRefresh(existing: string, desired: string): string;
 export declare function ensureGitattributes(projectDir: string, io: InitDepositIo): boolean;
 export declare function ensureGreptileIgnore(projectDir: string, io: InitDepositIo): boolean;
 export declare function ensureCodeqlPathsIgnore(projectDir: string, io: InitDepositIo): boolean;

package/dist/init-deposit/scaffold.js

@@ -457,7 +457,9 @@ export function ensureTaskfile(projectDir, io) {
     return true;
 }
 const HOOK_FILENAMES = ["pre-commit", "pre-push"];
+const HOOK_SUPPORT_FILENAMES = ["_deft-run.sh"];
 const HOOK_FILE_MODE = 0o755;
+const HOOK_SUPPORT_FILE_MODE = 0o644;
 export function writeConsumerGitHooks(projectDir, deftDir, io, seams = {}) {
     const srcDir = join(deftDir, ".githooks");
     if (!existsSync(srcDir) || !statSync(srcDir).isDirectory()) {
@@ -467,18 +469,20 @@ export function writeConsumerGitHooks(projectDir, deftDir, io, seams = {}) {
     const dstDir = join(projectDir, ".githooks");
     mkdirSync(dstDir, { recursive: true });
     let filesDeposited = false;
-    for (const name of HOOK_FILENAMES) {
+    for (const name of [...HOOK_FILENAMES, ...HOOK_SUPPORT_FILENAMES]) {
         const src = join(srcDir, name);
         if (!existsSync(src))
             continue;
         const data = readFileSync(src);
         const dst = join(dstDir, name);
         const existing = existsSync(dst) ? readFileSync(dst) : null;
+        const isHookScript = HOOK_FILENAMES.includes(name);
         if (!existing?.equals(data)) {
-            writeFileSync(dst, data, { mode: HOOK_FILE_MODE });
+            const mode = isHookScript ? HOOK_FILE_MODE : HOOK_SUPPORT_FILE_MODE;
+            writeFileSync(dst, data, { mode });
             filesDeposited = true;
         }
-        if (platform() !== "win32") {
+        if (platform() !== "win32" && isHookScript) {
             try {
                 const mode = statSync(dst).mode & 0o777;
                 if ((mode & 0o111) === 0) {
@@ -538,6 +542,78 @@ export function writeConsumerGitHooks(projectDir, deftDir, io, seams = {}) {
 function githubActionsExpr(expression) {
     return ["$", "{{ ", expression, " }}"].join("");
 }
+/** Commit SHA for `actions/checkout` deposited in deft-core-guard.yml (#1672 / #1072). */
+export const CORE_GUARD_CHECKOUT_SHA = "9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0";
+/** Tag comment paired with {@link CORE_GUARD_CHECKOUT_SHA}. */
+export const CORE_GUARD_CHECKOUT_TAG = "v7.0.0";
+const CHECKOUT_USES_PREFIX = "- uses: actions/checkout@";
+/**
+ * Extract the `uses: actions/checkout@…` step line from a guard workflow, if present.
+ * Uses linear string scanning (no regex) to avoid CodeQL js/polynomial-redos (#1672).
+ */
+export function extractCoreGuardCheckoutUsesLine(content) {
+    for (const line of content.split("\n")) {
+        const trimmed = line.trimStart();
+        if (!trimmed.startsWith(CHECKOUT_USES_PREFIX))
+            continue;
+        // YAML step lines are indented; a bare top-level match is not a step.
+        if (trimmed.length === line.length)
+            continue;
+        return line;
+    }
+    return null;
+}
+/** Ref after `actions/checkout@` (tag, SHA, or major), stopping at whitespace. */
+function checkoutActionRef(usesLine) {
+    const idx = usesLine.indexOf(CHECKOUT_USES_PREFIX);
+    if (idx < 0)
+        return null;
+    const after = usesLine.slice(idx + CHECKOUT_USES_PREFIX.length);
+    let end = after.length;
+    for (let i = 0; i < after.length; i += 1) {
+        const c = after[i];
+        if (c === " " || c === "\t" || c === "\r") {
+            end = i;
+            break;
+        }
+    }
+    const ref = after.slice(0, end);
+    return ref.length > 0 ? ref : null;
+}
+/**
+ * Whether refresh should keep the existing checkout pin instead of the template pin.
+ * Legacy framework-deposited `@v4` tags migrate forward; consumer/Dependabot bumps do not.
+ */
+export function shouldPreserveCoreGuardCheckoutPin(existingUsesLine, desiredUsesLine) {
+    if (existingUsesLine === desiredUsesLine)
+        return false;
+    const existingRef = checkoutActionRef(existingUsesLine);
+    if (!existingRef)
+        return false;
+    // Stale framework-deposited floating major tag — migrate to SHA template (#1672).
+    return existingRef !== "v4";
+}
+/** Canonical SHA-pinned checkout step for the deposited deft-core-guard workflow. */
+export function coreGuardCheckoutUsesLine(sha = CORE_GUARD_CHECKOUT_SHA, tag = CORE_GUARD_CHECKOUT_TAG) {
+    return `      - uses: actions/checkout@${sha} # ${tag}`;
+}
+/**
+ * On refresh, preserve an existing consumer `actions/checkout@…` pin while updating
+ * the managed guard script / allowlist body (#1672 option 1).
+ */
+export function mergeCoreGuardWorkflowRefresh(existing, desired) {
+    const existingCheckout = extractCoreGuardCheckoutUsesLine(existing);
+    if (!existingCheckout)
+        return desired;
+    const desiredCheckout = extractCoreGuardCheckoutUsesLine(desired);
+    if (!desiredCheckout || !shouldPreserveCoreGuardCheckoutPin(existingCheckout, desiredCheckout)) {
+        return desired;
+    }
+    const idx = desired.indexOf(desiredCheckout);
+    if (idx < 0)
+        return desired;
+    return desired.slice(0, idx) + existingCheckout + desired.slice(idx + desiredCheckout.length);
+}
 function coreGuardWorkflowContent() {
     const baseSha = githubActionsExpr("github.event.pull_request.base.sha");
     const headSha = githubActionsExpr("github.event.pull_request.head.sha");
@@ -555,7 +631,7 @@ function coreGuardWorkflowContent() {
         "  no-mixed-core-and-app:\n" +
         "    runs-on: ubuntu-latest\n" +
         "    steps:\n" +
-        "      - uses: actions/checkout@v4\n" +
+        `${coreGuardCheckoutUsesLine()}\n` +
         "        with:\n" +
         "          fetch-depth: 0\n" +
         "      - name: Refuse PRs that mix .deft/core/** with non-framework paths\n" +
@@ -715,15 +791,16 @@ export function ensureCoreGuardWorkflow(projectDir, io) {
     const desired = coreGuardWorkflowContent();
     if (existsSync(path)) {
         const existing = readFileSync(path, "utf8");
-        if (existing === desired) {
-            io.printf(`${CORE_GUARD_WORKFLOW_REL} already current — skipping.\n`);
-            return false;
-        }
         if (!existing.includes("name: deft-core-guard")) {
             io.printf(`${CORE_GUARD_WORKFLOW_REL} present but not deft-managed — leaving unchanged.\n`);
             return false;
         }
-        writeFileSync(path, desired, "utf8");
+        const refreshed = mergeCoreGuardWorkflowRefresh(existing, desired);
+        if (existing === refreshed) {
+            io.printf(`${CORE_GUARD_WORKFLOW_REL} already current — skipping.\n`);
+            return false;
+        }
+        writeFileSync(path, refreshed, "utf8");
         io.printf(`${CORE_GUARD_WORKFLOW_REL} refreshed: deft-core-guard allowlist updated (#1478).\n`);
         return true;
     }

package/dist/intake/issue-emit.js

@@ -1,6 +1,6 @@
 import { globSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join, relative, resolve } from "node:path";
+import { isAbsolute, join, relative, resolve } from "node:path";
 import { referenceTypeMatches } from "@deftai/directive-types";
 import { call } from "../scm/call.js";
 import { resolveProjectRoot } from "../scope/project-context.js";
@@ -217,7 +217,7 @@ export function expandPatterns(patterns, root = null) {
     const seen = new Set();
     const out = [];
     for (const pattern of patterns) {
-        const candidate = root !== null && !pattern.startsWith("/") ? join(root, pattern) : pattern;
+        const candidate = root !== null && !isAbsolute(pattern) ? join(root, pattern) : pattern;
         let matches = globSync(candidate).sort();
         if (matches.length === 0) {
             try {

package/dist/policy/agents-md-budget.d.ts

@@ -9,9 +9,32 @@
  * it is an explicit, reviewed diff to this typed field -- that diff IS the
  * "was this growth deliberate?" checkpoint.
  */
+export type HarnessProfile = "cursor" | "none";
+export type SkillFrontmatterTier = "daily-core" | "all" | "none";
 export interface AgentsMdBudget {
     readonly managedMaxLines: number;
     readonly unmanagedMaxLines: number;
+    /**
+     * Fail-closed UTF-8 byte ratchet for the managed section (#2452).
+     * Seeded at the current measured size so the gate ships green; growth past
+     * this ceiling fails. The <=8192 B north-star is reported separately.
+     */
+    readonly absoluteMaxBytes?: number;
+    /**
+     * Harness profile for DD-3 skill-frontmatter measurement (#2463).
+     * When unset, the gate auto-detects `cursor` when `content/skills/` exists.
+     */
+    readonly harnessProfile?: HarnessProfile;
+    /**
+     * Skill tier for DD-3 frontmatter caps (`daily-core` vs `all` vs `none`).
+     * Defaults to `all` for reporting when unset.
+     */
+    readonly skillFrontmatterTier?: SkillFrontmatterTier;
+    /**
+     * Optional fail-closed ratchet for DD-3 skill-frontmatter bytes (#2463).
+     * Advisory when unset; growth past this ceiling fails when set.
+     */
+    readonly skillFrontmatterMaxBytes?: number;
 }
 export type AgentsMdBudgetSource = "typed" | "unset" | "default-on-error";
 export interface AgentsMdBudgetResult {

package/dist/policy/agents-md-budget.js

@@ -39,6 +39,19 @@ function readRegion(block, key) {
     }
     return { value: raw, error: null };
 }
+function readOptionalRegion(block, key) {
+    if (!(key in block)) {
+        return { value: undefined, error: null };
+    }
+    const raw = block[key];
+    if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 0) {
+        return {
+            value: undefined,
+            error: `plan.policy.agentsMdBudget.${key} must be a non-negative integer; got ${pythonTypeName(raw)} (${pythonRepr(raw)})`,
+        };
+    }
+    return { value: raw, error: null };
+}
 /** Resolve plan.policy.agentsMdBudget from PROJECT-DEFINITION (#645). */
 export function resolveAgentsMdBudget(projectRoot) {
     const [data, err] = loadProjectDefinition(projectRoot);
@@ -77,13 +90,71 @@ export function resolveAgentsMdBudget(projectRoot) {
     if (unmanaged.error !== null) {
         return { budget: null, source: "default-on-error", error: unmanaged.error };
     }
+    const absolute = readOptionalRegion(block, "absoluteMaxBytes");
+    if (absolute.error !== null) {
+        return { budget: null, source: "default-on-error", error: absolute.error };
+    }
+    const skillFrontmatterMax = readOptionalRegion(block, "skillFrontmatterMaxBytes");
+    if (skillFrontmatterMax.error !== null) {
+        return { budget: null, source: "default-on-error", error: skillFrontmatterMax.error };
+    }
+    const harnessProfile = readOptionalHarnessProfile(block, "harnessProfile");
+    if (harnessProfile.error !== null) {
+        return { budget: null, source: "default-on-error", error: harnessProfile.error };
+    }
+    const skillFrontmatterTier = readOptionalSkillTier(block, "skillFrontmatterTier");
+    if (skillFrontmatterTier.error !== null) {
+        return { budget: null, source: "default-on-error", error: skillFrontmatterTier.error };
+    }
+    const budget = {
+        managedMaxLines: managed.value,
+        unmanagedMaxLines: unmanaged.value,
+    };
+    const withOptional = {
+        ...budget,
+        ...(absolute.value !== undefined ? { absoluteMaxBytes: absolute.value } : {}),
+        ...(skillFrontmatterMax.value !== undefined
+            ? { skillFrontmatterMaxBytes: skillFrontmatterMax.value }
+            : {}),
+        ...(harnessProfile.value !== undefined ? { harnessProfile: harnessProfile.value } : {}),
+        ...(skillFrontmatterTier.value !== undefined
+            ? { skillFrontmatterTier: skillFrontmatterTier.value }
+            : {}),
+    };
     return {
-        budget: {
-            managedMaxLines: managed.value,
-            unmanagedMaxLines: unmanaged.value,
-        },
+        budget: withOptional,
         source: "typed",
         error: null,
     };
 }
+const HARNESS_PROFILES = new Set(["cursor", "none"]);
+const SKILL_FRONTMATTER_TIERS = new Set(["daily-core", "all", "none"]);
+function readOptionalHarnessProfile(block, key) {
+    if (!(key in block)) {
+        return { value: undefined, error: null };
+    }
+    const raw = block[key];
+    if (typeof raw !== "string" || !HARNESS_PROFILES.has(raw)) {
+        return {
+            value: undefined,
+            error: `plan.policy.agentsMdBudget.${key} must be one of ${[...HARNESS_PROFILES].join(", ")}; ` +
+                `got ${pythonTypeName(raw)} (${pythonRepr(raw)})`,
+        };
+    }
+    return { value: raw, error: null };
+}
+function readOptionalSkillTier(block, key) {
+    if (!(key in block)) {
+        return { value: undefined, error: null };
+    }
+    const raw = block[key];
+    if (typeof raw !== "string" || !SKILL_FRONTMATTER_TIERS.has(raw)) {
+        return {
+            value: undefined,
+            error: `plan.policy.agentsMdBudget.${key} must be one of ${[...SKILL_FRONTMATTER_TIERS].join(", ")}; ` +
+                `got ${pythonTypeName(raw)} (${pythonRepr(raw)})`,
+        };
+    }
+    return { value: raw, error: null };
+}
 //# sourceMappingURL=agents-md-budget.js.map

package/dist/pr-merge-readiness/constants.d.ts

@@ -3,6 +3,10 @@ export declare const EXIT_MERGE_BLOCKED = 1;
 export declare const EXIT_EXTERNAL_ERROR = 2;
 export declare const GREPTILE_LOGIN = "greptile-apps[bot]";
 export declare const GREPTILE_ERRORED_SENTINEL = "Greptile encountered an error while reviewing this PR";
+/** Greptile status marker on excluded-author skip comments (#2375). */
+export declare const GREPTILE_STATUS_MARKER = "<!-- greptile-status -->";
+/** Substring Greptile posts when the PR author is on the excluded-authors list (#2375). */
+export declare const GREPTILE_EXCLUDED_AUTHOR_PHRASE = "excluded authors list";
 export declare const LAST_REVIEWED_RE: RegExp;
 export declare const CONFIDENCE_RE: RegExp;
 export declare const P0_BADGE = "<img alt=\"P0\"";

package/dist/pr-merge-readiness/constants.js

@@ -3,6 +3,10 @@ export const EXIT_MERGE_BLOCKED = 1;
 export const EXIT_EXTERNAL_ERROR = 2;
 export const GREPTILE_LOGIN = "greptile-apps[bot]";
 export const GREPTILE_ERRORED_SENTINEL = "Greptile encountered an error while reviewing this PR";
+/** Greptile status marker on excluded-author skip comments (#2375). */
+export const GREPTILE_STATUS_MARKER = "<!-- greptile-status -->";
+/** Substring Greptile posts when the PR author is on the excluded-authors list (#2375). */
+export const GREPTILE_EXCLUDED_AUTHOR_PHRASE = "excluded authors list";
 export const LAST_REVIEWED_RE = /Last reviewed commit:\s*\[[^\]]*\]\(https?:\/\/github\.com\/[^/]+\/[^/]+\/commit\/(?<sha>[0-9a-f]{7,40})/g;
 export const CONFIDENCE_RE = /Confidence Score:\s*(?<score>\d+)\s*\/\s*5/i;
 export const P0_BADGE = '<img alt="P0"';

package/dist/pr-merge-readiness/evaluate.js

@@ -8,6 +8,9 @@ export function evaluateGates(_prNumber, headSha, verdict) {
             "Wait for the review to land before merging (see #796 late-bot-review re-check).");
         return failures;
     }
+    if (verdict.excludedAuthor) {
+        return failures;
+    }
     if (verdict.errored) {
         failures.push("Greptile review is in the ERRORED state on the current HEAD (#526). " +
             "Retry via @greptileai or escalate per " +

package/dist/pr-merge-readiness/mergeability.d.ts

@@ -31,13 +31,15 @@ export declare function verdictShaIsStale(verdict: GreptileVerdict, headSha: str
  * Classify whether the verdict-based merge block is ONLY "soft" (#2260).
  *
  * A soft block means the review verdict is absent or pinned to a prior head
- * SHA (rebased staleness) -- i.e. the review has not spoken about the CURRENT
- * head. It is safe to reconcile a soft block against GitHub mergeability.
+ * SHA without carrying real blocker-class findings (rebased staleness with no
+ * P0/P1/errored/low-confidence) -- i.e. the review has not spoken about the
+ * CURRENT head in a blocking way. It is safe to reconcile a soft block against
+ * GitHub mergeability.
  *
- * A HARD block -- a genuine P0/P1 finding, an ERRORED review, or a low
- * confidence score on the current head -- is NEVER soft; those must keep
- * blocking regardless of GitHub mergeability (guardrail: do not merge a PR
- * with a real P0/P1 review finding).
+ * A HARD block -- a genuine P0/P1 finding (even on a stale SHA), an ERRORED
+ * review, or a low confidence score -- is NEVER soft; those must keep blocking
+ * regardless of GitHub mergeability (guardrail: do not merge a PR with a real
+ * P0/P1 review finding).
  */
 export declare function verdictBlockIsSoftOnly(verdict: GreptileVerdict, headSha: string | null): boolean;
 //# sourceMappingURL=mergeability.d.ts.map

package/dist/pr-merge-readiness/mergeability.js

@@ -65,13 +65,15 @@ export function verdictShaIsStale(verdict, headSha) {
  * Classify whether the verdict-based merge block is ONLY "soft" (#2260).
  *
  * A soft block means the review verdict is absent or pinned to a prior head
- * SHA (rebased staleness) -- i.e. the review has not spoken about the CURRENT
- * head. It is safe to reconcile a soft block against GitHub mergeability.
+ * SHA without carrying real blocker-class findings (rebased staleness with no
+ * P0/P1/errored/low-confidence) -- i.e. the review has not spoken about the
+ * CURRENT head in a blocking way. It is safe to reconcile a soft block against
+ * GitHub mergeability.
  *
- * A HARD block -- a genuine P0/P1 finding, an ERRORED review, or a low
- * confidence score on the current head -- is NEVER soft; those must keep
- * blocking regardless of GitHub mergeability (guardrail: do not merge a PR
- * with a real P0/P1 review finding).
+ * A HARD block -- a genuine P0/P1 finding (even on a stale SHA), an ERRORED
+ * review, or a low confidence score -- is NEVER soft; those must keep blocking
+ * regardless of GitHub mergeability (guardrail: do not merge a PR with a real
+ * P0/P1 review finding).
  */
 export function verdictBlockIsSoftOnly(verdict, headSha) {
     // Absent: no Greptile rolling-summary comment at all.
@@ -83,12 +85,11 @@ export function verdictBlockIsSoftOnly(verdict, headSha) {
     if (verdict.informalClean) {
         return false;
     }
-    // Stale: verdict pinned to a prior head SHA -> its findings pertain to old code.
-    if (verdictShaIsStale(verdict, headSha)) {
+    // Excluded-author skip is an intentional N/A reviewer state (#2375).
+    if (verdict.excludedAuthor) {
         return true;
     }
-    // Verdict is current (or its SHA is unparseable). A genuine current-head
-    // finding is a hard block and must not be overridden.
+    // Blocker-class signals apply even when the verdict SHA is stale (#2382).
     if (verdict.errored) {
         return false;
     }
@@ -98,6 +99,10 @@ export function verdictBlockIsSoftOnly(verdict, headSha) {
     if (verdict.p0Count > 0 || verdict.p1Count > 0) {
         return false;
     }
+    // Stale without blocker findings: review has not spoken about the current head.
+    if (verdictShaIsStale(verdict, headSha)) {
+        return true;
+    }
     // No genuine finding: the block is a missing-canonical-field / not-yet-posted
     // wait, which GitHub mergeability may resolve.
     return true;

package/dist/pr-merge-readiness/output.js

@@ -10,6 +10,7 @@ function verdictToDict(verdict) {
         p1_count: verdict.p1Count,
         p2_count: verdict.p2Count,
         informal_clean: verdict.informalClean,
+        excluded_author: verdict.excludedAuthor,
         raw_body_excerpt: verdict.rawBodyExcerpt,
     };
 }
@@ -47,12 +48,17 @@ export function printHuman(result) {
     const lines = [];
     lines.push(`PR #${result.prNumber} merge-readiness check  (via=${result.via})`);
     lines.push(`  HEAD SHA:           ${result.headSha ?? "<unknown>"}`);
-    lines.push(`  Greptile reviewed:  ${result.verdict.lastReviewedSha ?? "<not parsed>"}`);
-    const confidenceStr = result.verdict.confidence !== null ? String(result.verdict.confidence) : "<not parsed>";
-    lines.push(`  Confidence:         ${confidenceStr}/5`);
-    lines.push(`  Findings:           P0=${result.verdict.p0Count}  ` +
-        `P1=${result.verdict.p1Count}  P2=${result.verdict.p2Count}`);
-    lines.push(`  Errored sentinel:   ${result.verdict.errored ? "True" : "False"}`);
+    if (result.verdict.excludedAuthor) {
+        lines.push("  Greptile review:    skipped (author excluded)");
+    }
+    else {
+        lines.push(`  Greptile reviewed:  ${result.verdict.lastReviewedSha ?? "<not parsed>"}`);
+        const confidenceStr = result.verdict.confidence !== null ? String(result.verdict.confidence) : "<not parsed>";
+        lines.push(`  Confidence:         ${confidenceStr}/5`);
+        lines.push(`  Findings:           P0=${result.verdict.p0Count}  ` +
+            `P1=${result.verdict.p1Count}  P2=${result.verdict.p2Count}`);
+        lines.push(`  Errored sentinel:   ${result.verdict.errored ? "True" : "False"}`);
+    }
     const ciBlock = result.partialData.ci;
     if (ciBlock !== null && typeof ciBlock === "object" && !Array.isArray(ciBlock)) {
         const ci = ciBlock;

package/dist/pr-merge-readiness/parse.d.ts

@@ -1,5 +1,6 @@
 import type { GreptileVerdict } from "./types.js";
 export declare function emptyVerdict(): GreptileVerdict;
+export declare function isGreptileExcludedAuthor(body: string): boolean;
 export declare function isInformalCleanMissingCanonicalFields(verdict: GreptileVerdict, body: string): boolean;
 /** Parse a Greptile rolling-summary comment body into a structured verdict. */
 export declare function parseGreptileBody(body: string): GreptileVerdict;

package/dist/pr-merge-readiness/parse.js

@@ -1,5 +1,5 @@
 import { findLastReviewedCommitSha } from "../text/redos-safe.js";
-import { CONFIDENCE_RE, GREPTILE_ERRORED_SENTINEL, INFORMAL_CLEAN_SIGNAL_RE, P0_BADGE, P1_BADGE, SECTION_RE, } from "./constants.js";
+import { CONFIDENCE_RE, GREPTILE_ERRORED_SENTINEL, GREPTILE_EXCLUDED_AUTHOR_PHRASE, GREPTILE_STATUS_MARKER, INFORMAL_CLEAN_SIGNAL_RE, P0_BADGE, P1_BADGE, SECTION_RE, } from "./constants.js";
 export function emptyVerdict() {
     return {
         found: false,
@@ -10,9 +10,15 @@ export function emptyVerdict() {
         p1Count: 0,
         p2Count: 0,
         informalClean: false,
+        excludedAuthor: false,
         rawBodyExcerpt: "",
     };
 }
+export function isGreptileExcludedAuthor(body) {
+    const lower = body.toLowerCase();
+    return (lower.includes(GREPTILE_EXCLUDED_AUTHOR_PHRASE) &&
+        (lower.includes("greptile-status") || body.includes(GREPTILE_STATUS_MARKER)));
+}
 export function isInformalCleanMissingCanonicalFields(verdict, body) {
     if (!verdict.found || verdict.errored) {
         return false;
@@ -42,6 +48,7 @@ export function parseGreptileBody(body) {
         return emptyVerdict();
     }
     const errored = body.trim().startsWith(GREPTILE_ERRORED_SENTINEL);
+    const excludedAuthor = isGreptileExcludedAuthor(body);
     const lastReviewedSha = findLastReviewedCommitSha(body);
     const confMatch = CONFIDENCE_RE.exec(body);
     const confidence = confMatch?.groups?.score !== undefined ? Number(confMatch.groups.score) : null;
@@ -73,6 +80,7 @@ export function parseGreptileBody(body) {
         p1Count,
         p2Count,
         informalClean: false,
+        excludedAuthor,
         rawBodyExcerpt: body.slice(0, 200),
     };
     if (isInformalCleanMissingCanonicalFields(verdict, body)) {

package/dist/pr-merge-readiness/types.d.ts

@@ -7,6 +7,8 @@ export interface GreptileVerdict {
     readonly p1Count: number;
     readonly p2Count: number;
     readonly informalClean: boolean;
+    /** Greptile deliberately skipped review for an excluded PR author (#2375). */
+    readonly excludedAuthor: boolean;
     readonly rawBodyExcerpt: string;
 }
 export interface GateResult {

package/dist/preflight-cache/evaluate.d.ts

@@ -17,6 +17,8 @@ export declare const CANDIDATES_RELPATH: string;
 export declare const DEFAULT_MAX_AGE_HOURS = 24;
 export declare const ENV_MAX_AGE_HOURS = "DEFT_CACHE_MAX_AGE_HOURS";
 export declare const ENV_TRIAGE_REPO = "DEFT_TRIAGE_REPO";
+/** Set by releaseSubprocessEnv() during task release Step 5 (#2386). */
+export declare const ENV_RELEASE_PREFLIGHT = "DEFT_RELEASE_PREFLIGHT";
 export declare const REQUIRED_DECISION = "accept";
 export interface GateResult {
     readonly code: number;