@deftai/directive-core 0.73.1 → 0.74.0

package/dist/check/orchestrator.d.ts

@@ -19,10 +19,13 @@ export interface CheckOrchestratorSeams {
     readonly spawnFn?: (cmd: string, args: string[], opts: {
         cwd: string;
         stdio: string;
+        env?: NodeJS.ProcessEnv;
     }) => {
         status: number | null;
         error?: Error;
     };
+    /** Child-process environment (default: process.env). */
+    readonly env?: NodeJS.ProcessEnv;
 }
 /**
  * True when `path` is the directive framework source checkout root (not a

package/dist/check/orchestrator.js

@@ -77,6 +77,7 @@ export function dispatchTaskCheck(frameworkRoot, projectRoot, seams = {}) {
     const result = spawn(taskBin, [target, "--taskfile", taskfilePath], {
         cwd,
         stdio: "inherit",
+        env: seams.env,
     });
     if (result.error !== undefined) {
         process.stderr.write(`check: failed to invoke task: ${result.error.message}\n`);
@@ -88,7 +89,7 @@ function defaultSpawn(cmd, args, opts) {
     const result = spawnSync(cmd, args, {
         cwd: opts.cwd,
         stdio: opts.stdio,
-        env: { ...process.env },
+        env: opts.env ?? process.env,
     });
     return { status: result.status, error: result.error };
 }

package/dist/codebase/map.js

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { assertProjectionContained } from "../fs/projection-containment.js";
 import { resolveProjectDefinitionPath } from "../layout/resolve.js";
 import { extractCodeStructure, loadJsonFile } from "../verify-source/code-structure-validate.js";
 import { CodeStructureConfigError, configErrorToDict, defaultCodeStructurePath, } from "./default-extractor.js";
@@ -239,6 +240,7 @@ export function writeCodebaseMap(projectRoot, options) {
     const resolvedOutput = isAbsolute(options.outputPath)
         ? options.outputPath
         : join(projectRoot, options.outputPath);
+    assertProjectionContained(projectRoot, resolvedOutput);
     if (!options.force && !isDeftGenerated(resolvedOutput)) {
         throw new Error(`refusing to overwrite non-generated MAP at ${resolvedOutput}; ` +
             `missing '${GENERATED_SENTINEL}' banner`);

package/dist/doctor/checks.d.ts

@@ -30,6 +30,15 @@ export declare function checkCanonicalVendoredNpmSignpost(projectRoot: string, s
  * deposit is still a working install, just an unpinned one.
  */
 export declare function checkManifestVersionReportable(projectRoot: string, installRoot: string | null, seams?: CheckSeams): CheckResult;
+/** Relative path to the deposited v0.6 schema file superseded by xbrief-core-0.8.schema.json. */
+export declare const STALE_VBRIEF_CORE_SCHEMA_REL: string;
+/**
+ * #2368: on an already-migrated xbrief/ layout, a stale deposited
+ * `xbrief/schemas/vbrief-core.schema.json` (vBRIEFInfo v0.6) must NOT route
+ * operators to `migrate:xbrief` — that verb requires a vbrief/ tree. Point at
+ * `directive update` instead. Advisory only (exit-exempt).
+ */
+export declare function checkStaleXbriefSchemaDeposit(projectRoot: string, seams?: CheckSeams): CheckResult;
 /**
  * #2206: check that the consumer `.gitignore` carries the canonical Deft baseline
  * entries. Advisory (exit-exempt) because missing entries are an adoption risk, not

package/dist/doctor/checks.js

@@ -5,6 +5,8 @@ import { detectCanonicalVendoredManifest, isNpmManaged, NPM_MANAGED_SENTINEL_KEY
 import { resolveLifecycleRoot } from "../layout/resolve.js";
 import { findSkillPathsInText } from "../text/redos-safe.js";
 import { stripGitignoreInlineComment } from "../triage/bootstrap/gitignore.js";
+import { LEGACY_INFO_ROOT_KEY, MIGRATED_ARTIFACT_DIR } from "../xbrief-migrate/constants.js";
+import { detectXbriefConvergence } from "../xbrief-migrate/detect.js";
 import { CANONICAL_UPGRADE_COMMAND, GO_BRIDGE_RELEASES_URL, UPGRADING_DOC_URL, } from "./constants.js";
 import { isDeprecationRedirectStub, locateManifest, manifestCandidatePaths, manifestReportableVersion, manifestTagToVersion, parseInstallManifest, parseInstallRootFromAgentsMd, parseManifest, } from "./manifest.js";
 import { readTextSafe } from "./paths.js";
@@ -459,6 +461,68 @@ function collectGitignorePresent(text) {
 function gitignoreLineIsCovered(present, line) {
     return present.has(line);
 }
+/** Relative path to the deposited v0.6 schema file superseded by xbrief-core-0.8.schema.json. */
+export const STALE_VBRIEF_CORE_SCHEMA_REL = join(MIGRATED_ARTIFACT_DIR, "schemas", "vbrief-core.schema.json");
+const MIGRATED_XBRIEF_LAYOUT_STATES = new Set([
+    "xbrief-only",
+    "xbrief-marker",
+]);
+/**
+ * #2368: on an already-migrated xbrief/ layout, a stale deposited
+ * `xbrief/schemas/vbrief-core.schema.json` (vBRIEFInfo v0.6) must NOT route
+ * operators to `migrate:xbrief` — that verb requires a vbrief/ tree. Point at
+ * `directive update` instead. Advisory only (exit-exempt).
+ */
+export function checkStaleXbriefSchemaDeposit(projectRoot, seams = {}) {
+    const checkName = "stale-xbrief-schema-deposit";
+    const convergence = detectXbriefConvergence(projectRoot);
+    if (!MIGRATED_XBRIEF_LAYOUT_STATES.has(convergence.state)) {
+        return {
+            name: checkName,
+            status: "skip",
+            detail: "Project is not on a fully migrated xbrief/ layout; stale schema deposit check does not apply.",
+            data: { convergence_state: convergence.state },
+        };
+    }
+    const schemaPath = join(projectRoot, STALE_VBRIEF_CORE_SCHEMA_REL);
+    const isFile = seams.isFile ?? ((p) => readText(p, seams) !== null);
+    if (!isFile(schemaPath)) {
+        return {
+            name: checkName,
+            status: "skip",
+            detail: `No deposited schema at ${STALE_VBRIEF_CORE_SCHEMA_REL}.`,
+            data: { schema_path: schemaPath },
+        };
+    }
+    const text = readText(schemaPath, seams);
+    if (text === null) {
+        return {
+            name: checkName,
+            status: "skip",
+            detail: `Deposited schema at ${STALE_VBRIEF_CORE_SCHEMA_REL} is unreadable.`,
+            data: { schema_path: schemaPath },
+        };
+    }
+    if (!text.includes(`"${LEGACY_INFO_ROOT_KEY}"`)) {
+        return {
+            name: checkName,
+            status: "pass",
+            detail: `Deposited schema at ${STALE_VBRIEF_CORE_SCHEMA_REL} is current (no ${LEGACY_INFO_ROOT_KEY} root key).`,
+            data: { schema_path: schemaPath },
+        };
+    }
+    return {
+        name: checkName,
+        status: "fail",
+        detail: `Stale deposited schema at ${STALE_VBRIEF_CORE_SCHEMA_REL} still carries the legacy ${LEGACY_INFO_ROOT_KEY} root key on an already-migrated xbrief/ layout. ` +
+            "Run `directive update` to refresh deposited schema files — not `deft migrate:xbrief` (no vbrief/ tree remains to convert).",
+        data: {
+            schema_path: schemaPath,
+            convergence_state: convergence.state,
+            suggested_fix: "directive update",
+        },
+    };
+}
 /**
  * #2206: check that the consumer `.gitignore` carries the canonical Deft baseline
  * entries. Advisory (exit-exempt) because missing entries are an adoption risk, not
@@ -515,6 +579,7 @@ export function deriveExitCode(checks, errors) {
         "canonical-vendored-npm-signpost",
         "manifest-version-reportable",
         "gitignore-coverage",
+        "stale-xbrief-schema-deposit",
     ]);
     if (errors.length > 0 || checks.some((c) => c.status === "error")) {
         return 2;
@@ -554,6 +619,7 @@ export function runChecksImpl(projectRoot, seams = {}) {
         checks.push(checkManifestVersionReportable(projectRoot, null, seams));
         checks.push(checkLegacyLayout(projectRoot, seams));
         checks.push(checkCanonicalVendoredNpmSignpost(projectRoot, seams));
+        checks.push(checkStaleXbriefSchemaDeposit(projectRoot, seams));
         checks.push(checkGitignoreCoverage(projectRoot, seams));
         return {
             projectRoot,
@@ -570,6 +636,7 @@ export function runChecksImpl(projectRoot, seams = {}) {
     checks.push(checkInstallPathConsistency(projectRoot, installRoot, seams));
     checks.push(checkLegacyLayout(projectRoot, seams));
     checks.push(checkCanonicalVendoredNpmSignpost(projectRoot, seams));
+    checks.push(checkStaleXbriefSchemaDeposit(projectRoot, seams));
     checks.push(checkGitignoreCoverage(projectRoot, seams));
     return {
         projectRoot,

package/dist/doctor/main.js

@@ -374,7 +374,8 @@ function runInstallIntegrityChecks(projectRoot, sink, addFinding, seams) {
             if ((name === "legacy-layout" ||
                 name === "canonical-vendored-npm-signpost" ||
                 name === "manifest-version-reportable" ||
-                name === "gitignore-coverage") &&
+                name === "gitignore-coverage" ||
+                name === "stale-xbrief-schema-deposit") &&
                 status === "fail") {
                 sink.warn(`${name}: ${detail}`);
                 addFinding({

package/dist/fs/projection-containment.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+/** Non-zero exit code for a projection-containment refusal (needs-action). */
+export declare const PROJECTION_CONTAINMENT_REFUSED_EXIT_CODE = 2;
+/** Thrown when a projection write target escapes the project tree. */
+export declare class ProjectionContainmentError extends Error {
+    readonly projectDir: string;
+    readonly targetPath: string;
+    readonly offendingPath: string;
+    constructor(message: string, details: {
+        projectDir: string;
+        targetPath: string;
+        offendingPath: string;
+    });
+}
+/**
+ * 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 declare function assertProjectionContained(projectDir: string, targetPath: string): void;
+//# sourceMappingURL=projection-containment.d.ts.map

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

@@ -538,6 +538,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 +627,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 +787,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/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;