@deftai/directive-core 0.93.0 → 0.95.0

package/dist/policy/index.js

@@ -4,6 +4,7 @@ import { FIELD_DELIVERY_BRANCH, FIELD_DELIVERY_BRANCH_CLI_ALIAS, inspectDelivery
 import { FIELD_HOST_HOOKS, FIELD_HOST_HOOKS_CLI_ALIAS, inspectHostHooks } from "./host-hooks.js";
 import { FIELD_HOST_SLASH_COMMANDS, FIELD_HOST_SLASH_COMMANDS_CLI_ALIAS, inspectHostSlashCommands, } from "./host-slash-commands.js";
 import { FIELD_HOTFIX_CRITERIA, FIELD_HOTFIX_CRITERIA_CLI_ALIAS, inspectHotfixCriteria, } from "./hotfix-criteria.js";
+import { FIELD_MIN_GREPTILE_CONFIDENCE, FIELD_MIN_GREPTILE_CONFIDENCE_CLI_ALIAS, inspectMinGreptileConfidence, } from "./min-greptile-confidence.js";
 import { readPlanPolicy } from "./plan-extensions.js";
 import { FIELD_PRODUCT_SIGNAL, FIELD_PRODUCT_SIGNAL_CLI_ALIAS, inspectProductSignal, } from "./product-signal.js";
 import { FIELD_REQUIRE_HUMAN_MERGE, FIELD_REQUIRE_HUMAN_MERGE_CLI_ALIAS, inspectRequireHumanMerge, } from "./require-human-merge.js";
@@ -23,6 +24,7 @@ export * from "./host-hooks.js";
 export * from "./host-slash-commands.js";
 export * from "./hotfix-criteria.js";
 export * from "./intent-ceiling.js";
+export * from "./min-greptile-confidence.js";
 export * from "./no-deft-directive.js";
 export * from "./org-force-on-migration.js";
 export * from "./plan-extensions.js";
@@ -44,6 +46,7 @@ export const FIELD_TRIAGE_SCOPE_IGNORES = "plan.policy.triageScopeIgnores";
 export const FIELD_TRIAGE_RANKING_LABELS = "plan.policy.triageRankingLabels";
 export const FIELD_TRIAGE_AUTO_CLASSIFY = "plan.policy.triageAutoClassify";
 export const FIELD_TRIAGE_HOLD_MARKERS = "plan.policy.triageHoldMarkers";
+export const FIELD_TRIAGE_LABEL_MIRROR = "plan.policy.triageLabelMirror";
 export const FIELD_SWARM_SUBAGENT_BACKEND = "plan.policy.swarmSubagentBackend";
 // deliveryBranch also exported from delivery-branch.js via export *
 export const DEFAULT_SESSION_RITUAL_STALENESS_HOURS = 4;
@@ -53,6 +56,13 @@ export const DEFAULT_TRIAGE_SCOPE_VALUE = [
 export const DEFAULT_TRIAGE_SCOPE_IGNORES_VALUE = [];
 export const DEFAULT_TRIAGE_RANKING_LABELS_VALUE = [];
 export const DEFAULT_TRIAGE_AUTO_CLASSIFY_VALUE = [];
+/** Default for #1423 Tier-1 label mirror: enabled with `triaged` idempotency marker. */
+export const DEFAULT_TRIAGE_LABEL_MIRROR_VALUE = {
+    enabled: true,
+    idempotencyLabel: "triaged",
+    alwaysLabels: ["triaged"],
+    actionLabels: {},
+};
 export const KNOWN_SUBAGENT_BACKEND_IDS = new Set(["composer", "cursor-cloud", "grok-build"]);
 const FALLBACK_HOLD_MARKERS = [
     "do not implement",
@@ -137,6 +147,32 @@ function inspectWipCap(data) {
         source: "default",
     };
 }
+function inspectTriageLabelMirrorField(data) {
+    const policyBlock = getPolicyBlock(data);
+    if ("triageLabelMirror" in policyBlock) {
+        const raw = policyBlock.triageLabelMirror;
+        if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+            return {
+                name: FIELD_TRIAGE_LABEL_MIRROR,
+                current: raw,
+                default: { ...DEFAULT_TRIAGE_LABEL_MIRROR_VALUE },
+                source: "typed",
+            };
+        }
+        return {
+            name: FIELD_TRIAGE_LABEL_MIRROR,
+            current: { ...DEFAULT_TRIAGE_LABEL_MIRROR_VALUE },
+            default: { ...DEFAULT_TRIAGE_LABEL_MIRROR_VALUE },
+            source: "default-on-error",
+        };
+    }
+    return {
+        name: FIELD_TRIAGE_LABEL_MIRROR,
+        current: { ...DEFAULT_TRIAGE_LABEL_MIRROR_VALUE },
+        default: { ...DEFAULT_TRIAGE_LABEL_MIRROR_VALUE },
+        source: "default",
+    };
+}
 function inspectSessionRitualStalenessHours(data) {
     const policyBlock = getPolicyBlock(data);
     if ("sessionRitualStalenessHours" in policyBlock) {
@@ -340,6 +376,15 @@ function inspectDeliveryBranchField(data, projectRoot) {
         source: field.source,
     };
 }
+function inspectMinGreptileConfidenceField(data, projectRoot) {
+    const field = inspectMinGreptileConfidence(data, projectRoot);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 const REGISTERED_POLICIES = [
     inspectAllowDirectCommits,
     inspectWipCap,
@@ -351,8 +396,10 @@ const REGISTERED_POLICIES = [
     (data) => listFieldInspector(data, "triageHoldMarkers", FIELD_TRIAGE_HOLD_MARKERS, defaultHoldMarkers(), {
         emptyIsTyped: true,
     }),
+    inspectTriageLabelMirrorField,
     inspectSwarmSubagentBackend,
     inspectDeliveryBranchField,
+    inspectMinGreptileConfidenceField,
     inspectHostHooksField,
     inspectHostSlashCommandsField,
     inspectOpenClawProductCommandsField,
@@ -393,7 +440,9 @@ export function inspectOnePolicy(name, projectRoot) {
                                             ? FIELD_HOTFIX_CRITERIA
                                             : name === FIELD_DELIVERY_BRANCH_CLI_ALIAS
                                                 ? FIELD_DELIVERY_BRANCH
-                                                : name;
+                                                : name === FIELD_MIN_GREPTILE_CONFIDENCE_CLI_ALIAS
+                                                    ? FIELD_MIN_GREPTILE_CONFIDENCE
+                                                    : name;
     for (const field of inspectAllPolicies(projectRoot)) {
         if (field.name === normalized)
             return field;

package/dist/policy/min-greptile-confidence.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Typed plan.policy.review.minGreptileConfidence (#3095).
+ *
+ * CLEAN / merge-ready require Greptile confidence >= min (score out of 5).
+ * Resolution order: explicit project policy > framework dogfood detect > consumer default.
+ *
+ * - Consumer default: 4 (legacy bar confidence > 3, i.e. 4/5 or 5/5)
+ * - Directive dogfood (framework source checkout): 5 (5/5 required)
+ */
+/** Canonical dotted path for policy:show / PROJECT-DEFINITION. */
+export declare const FIELD_MIN_GREPTILE_CONFIDENCE = "plan.policy.review.minGreptileConfidence";
+/** CLI alias for `task policy:show --field=minGreptileConfidence`. */
+export declare const FIELD_MIN_GREPTILE_CONFIDENCE_CLI_ALIAS = "minGreptileConfidence";
+/**
+ * Consumer default minimum confidence that still CLEANs (#3095).
+ * Matches the historical gate `confidence > 3` (i.e. score >= 4).
+ */
+export declare const DEFAULT_CONSUMER_MIN_GREPTILE_CONFIDENCE = 4;
+/** Directive dogfood bar: CLEAN requires confidence == 5/5. */
+export declare const DOGFOOD_MIN_GREPTILE_CONFIDENCE = 5;
+export declare const MIN_GREPTILE_CONFIDENCE_FLOOR = 1;
+export declare const MIN_GREPTILE_CONFIDENCE_CEILING = 5;
+export type MinGreptileConfidenceSource = "typed" | "dogfood" | "default" | "default-on-error";
+export interface MinGreptileConfidenceResolved {
+    /** Minimum score (1–5) that satisfies CLEAN; score must be >= min. */
+    readonly min: number;
+    readonly source: MinGreptileConfidenceSource;
+    readonly error: string | null;
+}
+/** True when score is present and meets the minimum floor. */
+export declare function meetsMinGreptileConfidence(confidence: number | null | undefined, min: number): boolean;
+/** Human-facing phrase for the active bar (legacy "> 3" when min is 4). */
+export declare function formatMinConfidenceRequirement(min: number): string;
+/** Validate a raw integer-ish min confidence value. */
+export declare function validateMinGreptileConfidence(raw: unknown): string | null;
+/**
+ * Read nested plan.policy.review.minGreptileConfidence from a policy block.
+ * Returns undefined when the key is absent.
+ */
+export declare function readMinGreptileConfidenceFromPolicyBlock(policyBlock: unknown): unknown | undefined;
+/**
+ * Resolve min Greptile confidence for CLEAN gates (#3095).
+ *
+ * 1. Explicit typed plan.policy.review.minGreptileConfidence
+ * 2. Framework dogfood detection (framework source repo root) → 5
+ * 3. Consumer default → 4
+ */
+export declare function resolveMinGreptileConfidence(projectRoot?: string | null): MinGreptileConfidenceResolved;
+export interface MinGreptileConfidencePolicyField {
+    readonly name: typeof FIELD_MIN_GREPTILE_CONFIDENCE;
+    readonly current: number;
+    readonly default: number;
+    readonly source: string;
+}
+/** Inspector row for `task policy:show --field=minGreptileConfidence` (#3095). */
+export declare function inspectMinGreptileConfidence(_data: Record<string, unknown> | null, projectRoot?: string): MinGreptileConfidencePolicyField;
+//# sourceMappingURL=min-greptile-confidence.d.ts.map

package/dist/policy/min-greptile-confidence.js

@@ -0,0 +1,123 @@
+/**
+ * Typed plan.policy.review.minGreptileConfidence (#3095).
+ *
+ * CLEAN / merge-ready require Greptile confidence >= min (score out of 5).
+ * Resolution order: explicit project policy > framework dogfood detect > consumer default.
+ *
+ * - Consumer default: 4 (legacy bar confidence > 3, i.e. 4/5 or 5/5)
+ * - Directive dogfood (framework source checkout): 5 (5/5 required)
+ */
+import { isFrameworkRepoRoot } from "../check/context.js";
+import { readPlanPolicy } from "./plan-extensions.js";
+import { loadProjectDefinition } from "./resolve.js";
+/** Canonical dotted path for policy:show / PROJECT-DEFINITION. */
+export const FIELD_MIN_GREPTILE_CONFIDENCE = "plan.policy.review.minGreptileConfidence";
+/** CLI alias for `task policy:show --field=minGreptileConfidence`. */
+export const FIELD_MIN_GREPTILE_CONFIDENCE_CLI_ALIAS = "minGreptileConfidence";
+/**
+ * Consumer default minimum confidence that still CLEANs (#3095).
+ * Matches the historical gate `confidence > 3` (i.e. score >= 4).
+ */
+export const DEFAULT_CONSUMER_MIN_GREPTILE_CONFIDENCE = 4;
+/** Directive dogfood bar: CLEAN requires confidence == 5/5. */
+export const DOGFOOD_MIN_GREPTILE_CONFIDENCE = 5;
+export const MIN_GREPTILE_CONFIDENCE_FLOOR = 1;
+export const MIN_GREPTILE_CONFIDENCE_CEILING = 5;
+function defaultResolved(source, min, error = null) {
+    return { min, source, error };
+}
+/** True when score is present and meets the minimum floor. */
+export function meetsMinGreptileConfidence(confidence, min) {
+    if (confidence === null || confidence === undefined) {
+        return false;
+    }
+    return confidence >= min;
+}
+/** Human-facing phrase for the active bar (legacy "> 3" when min is 4). */
+export function formatMinConfidenceRequirement(min) {
+    if (min === DEFAULT_CONSUMER_MIN_GREPTILE_CONFIDENCE) {
+        return `> ${min - 1} (i.e. ${min}/5+)`;
+    }
+    return `>= ${min}/5`;
+}
+/** Validate a raw integer-ish min confidence value. */
+export function validateMinGreptileConfidence(raw) {
+    if (typeof raw !== "number" || !Number.isInteger(raw)) {
+        return `${FIELD_MIN_GREPTILE_CONFIDENCE} must be an integer ${MIN_GREPTILE_CONFIDENCE_FLOOR}–${MIN_GREPTILE_CONFIDENCE_CEILING}; got ${typeof raw}`;
+    }
+    if (raw < MIN_GREPTILE_CONFIDENCE_FLOOR || raw > MIN_GREPTILE_CONFIDENCE_CEILING) {
+        return `${FIELD_MIN_GREPTILE_CONFIDENCE} must be between ${MIN_GREPTILE_CONFIDENCE_FLOOR} and ${MIN_GREPTILE_CONFIDENCE_CEILING}; got ${raw}`;
+    }
+    return null;
+}
+/**
+ * Read nested plan.policy.review.minGreptileConfidence from a policy block.
+ * Returns undefined when the key is absent.
+ */
+export function readMinGreptileConfidenceFromPolicyBlock(policyBlock) {
+    if (typeof policyBlock !== "object" || policyBlock === null || Array.isArray(policyBlock)) {
+        return undefined;
+    }
+    const rec = policyBlock;
+    if (!("review" in rec)) {
+        return undefined;
+    }
+    const review = rec.review;
+    if (typeof review !== "object" || review === null || Array.isArray(review)) {
+        return undefined;
+    }
+    const reviewRec = review;
+    if (!("minGreptileConfidence" in reviewRec)) {
+        return undefined;
+    }
+    return reviewRec.minGreptileConfidence;
+}
+/**
+ * Resolve min Greptile confidence for CLEAN gates (#3095).
+ *
+ * 1. Explicit typed plan.policy.review.minGreptileConfidence
+ * 2. Framework dogfood detection (framework source repo root) → 5
+ * 3. Consumer default → 4
+ */
+export function resolveMinGreptileConfidence(projectRoot) {
+    if (projectRoot !== undefined && projectRoot !== null && projectRoot.length > 0) {
+        const [data, err] = loadProjectDefinition(projectRoot);
+        if (data !== null) {
+            const policyBlock = readPlanPolicy(data.plan);
+            const raw = readMinGreptileConfidenceFromPolicyBlock(policyBlock);
+            if (raw !== undefined) {
+                const validationError = validateMinGreptileConfidence(raw);
+                if (validationError !== null) {
+                    // Invalid typed value: fall through to dogfood/default with error recorded.
+                    if (isFrameworkRepoRoot(projectRoot)) {
+                        return defaultResolved("dogfood", DOGFOOD_MIN_GREPTILE_CONFIDENCE, validationError);
+                    }
+                    return defaultResolved("default-on-error", DEFAULT_CONSUMER_MIN_GREPTILE_CONFIDENCE, validationError);
+                }
+                return defaultResolved("typed", raw, null);
+            }
+        }
+        else if (err !== null && err.length > 0) {
+            // Missing PROJECT-DEFINITION is not fatal; dogfood/default still apply.
+            if (isFrameworkRepoRoot(projectRoot)) {
+                return defaultResolved("dogfood", DOGFOOD_MIN_GREPTILE_CONFIDENCE, null);
+            }
+            return defaultResolved("default", DEFAULT_CONSUMER_MIN_GREPTILE_CONFIDENCE, err);
+        }
+        if (isFrameworkRepoRoot(projectRoot)) {
+            return defaultResolved("dogfood", DOGFOOD_MIN_GREPTILE_CONFIDENCE, null);
+        }
+    }
+    return defaultResolved("default", DEFAULT_CONSUMER_MIN_GREPTILE_CONFIDENCE, null);
+}
+/** Inspector row for `task policy:show --field=minGreptileConfidence` (#3095). */
+export function inspectMinGreptileConfidence(_data, projectRoot) {
+    const resolved = resolveMinGreptileConfidence(projectRoot);
+    return {
+        name: FIELD_MIN_GREPTILE_CONFIDENCE,
+        current: resolved.min,
+        default: DEFAULT_CONSUMER_MIN_GREPTILE_CONFIDENCE,
+        source: resolved.source,
+    };
+}
+//# sourceMappingURL=min-greptile-confidence.js.map

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

@@ -4,7 +4,7 @@ import { type InlineGreptileFindings } from "./greptile-inline.js";
 import { type MergeabilitySignal } from "./mergeability.js";
 import type { SlizardGateOptions } from "./slizard-gate.js";
 import type { GateResult, RunGhFn } from "./types.js";
-declare function buildGateResult(prNumber: number, repo: string | null, headSha: string | null, body: string, via: string, partialData?: Record<string, unknown>, error?: string | null, inline?: InlineGreptileFindings | null): GateResult;
+declare function buildGateResult(prNumber: number, repo: string | null, headSha: string | null, body: string, via: string, partialData?: Record<string, unknown>, error?: string | null, inline?: InlineGreptileFindings | null, minConfidence?: number): GateResult;
 /** Injectable GitHub-mergeability read seam (#2260) — keeps unit tests hermetic. */
 export type FetchMergeabilityFn = (prNumber: number, repo: string, runGh: RunGhFn) => MergeabilitySignal;
 export interface ComputeGateOptions extends CiGateOptions, SlizardGateOptions {
@@ -15,6 +15,16 @@ export interface ComputeGateOptions extends CiGateOptions, SlizardGateOptions {
      * off, an absent/stale review verdict blocks even on a GitHub-CLEAN PR.
      */
     readonly disableMergeabilityReconcile?: boolean;
+    /**
+     * Project root for resolving plan.policy.review.minGreptileConfidence (#3095).
+     * Defaults to process.cwd() when omitted.
+     */
+    readonly projectRoot?: string | null;
+    /**
+     * Override the resolved min confidence (1–5). When set, skips policy resolve.
+     * Tests and injectors use this; production callers leave it unset.
+     */
+    readonly minConfidence?: number;
 }
 /** Run the primary->fallback1->fallback2 cascade and return a result. */
 export declare function computeGateResult(prNumber: number, repo: string | null, runGh: RunGhFn, options?: ComputeGateOptions): GateResult;

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

@@ -1,3 +1,4 @@
+import { resolveMinGreptileConfidence } from "../policy/min-greptile-confidence.js";
 import { buildCiSummaryLine, evaluateCiGate } from "./ci-gate.js";
 import { FALLBACK2_NOT_CLEAN_MSG, VIA_ERROR, VIA_FALLBACK1, VIA_FALLBACK2, VIA_PRIMARY, } from "./constants.js";
 import { evaluateGates, isMergeReady } from "./evaluate.js";
@@ -6,9 +7,11 @@ import { fetchUnresolvedGreptileInlineFindings, inlineFindingsToDict, } from "./
 import { fetchMergeability, isGithubMergeableClean, mergeabilityToDict, verdictBlockIsSoftOnly, verdictShaIsStale, } from "./mergeability.js";
 import { emptyVerdict, parseGreptileBody } from "./parse.js";
 import { evaluateSlizardGate, isSlizardCheck } from "./slizard-gate.js";
-function buildGateResult(prNumber, repo, headSha, body, via, partialData = {}, error = null, inline = null) {
+function buildGateResult(prNumber, repo, headSha, body, via, partialData = {}, error = null, inline = null, minConfidence) {
     const verdict = parseGreptileBody(body);
-    const failures = evaluateGates(prNumber, headSha, verdict, inline);
+    const failures = evaluateGates(prNumber, headSha, verdict, inline, {
+        minConfidence,
+    });
     return {
         prNumber,
         repo,
@@ -20,6 +23,12 @@ function buildGateResult(prNumber, repo, headSha, body, via, partialData = {}, e
         error,
     };
 }
+function resolvedMinConfidence(options) {
+    if (options.minConfidence !== undefined) {
+        return options.minConfidence;
+    }
+    return resolveMinGreptileConfidence(options.projectRoot ?? process.cwd()).min;
+}
 /** Run the CI + SLizard gates off a single check-runs fetch (#2169 / #2189). */
 function evaluateCiAndSlizard(checkRuns, options) {
     const slizardResult = evaluateSlizardGate(checkRuns, options);
@@ -110,7 +119,11 @@ function finalizeVerdictGate(prNumber, repo, headSha, verdict, runGh, options) {
     const resolved = resolveRepo(repo, runGh);
     const inline = loadInlineGreptileFindings(prNumber, repo, headSha, runGh);
     partialData.greptile_inline = inlineFindingsToDict(inline);
-    const failures = evaluateGates(prNumber, headSha, verdict, inline);
+    const minConfidence = resolvedMinConfidence(options);
+    partialData.min_greptile_confidence = minConfidence;
+    const failures = evaluateGates(prNumber, headSha, verdict, inline, {
+        minConfidence,
+    });
     if (failures.length === 0) {
         const ci = applyCiGateForHead(resolved.repo, headSha, runGh, options);
         failures.push(...ci.failures);
@@ -123,7 +136,7 @@ function finalizeVerdictGate(prNumber, repo, headSha, verdict, runGh, options) {
     // blocking. Only reconcile a SOFT block (verdict absent / stale head SHA).
     if (options.disableMergeabilityReconcile === true ||
         resolved.repo === null ||
-        !verdictBlockIsSoftOnly(verdict, headSha, inline)) {
+        !verdictBlockIsSoftOnly(verdict, headSha, inline, minConfidence)) {
         return { failures, partialData };
     }
     const ci = applyCiGateForHead(resolved.repo, headSha, runGh, options);

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

@@ -1,6 +1,13 @@
 import type { InlineGreptileFindings } from "./greptile-inline.js";
 import type { GreptileVerdict } from "./types.js";
+export interface EvaluateGatesOptions {
+    /**
+     * Minimum Greptile confidence (1–5) that satisfies CLEAN (#3095).
+     * Defaults to the consumer bar (4 == legacy confidence > 3).
+     */
+    readonly minConfidence?: number;
+}
 /** Return failure messages (empty list == merge-ready). */
-export declare function evaluateGates(_prNumber: number, headSha: string | null, verdict: GreptileVerdict, inline?: InlineGreptileFindings | null): string[];
+export declare function evaluateGates(_prNumber: number, headSha: string | null, verdict: GreptileVerdict, inline?: InlineGreptileFindings | null, options?: EvaluateGatesOptions): string[];
 export declare function isMergeReady(failures: readonly string[]): boolean;
 //# sourceMappingURL=evaluate.d.ts.map

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

@@ -1,7 +1,9 @@
+import { DEFAULT_CONSUMER_MIN_GREPTILE_CONFIDENCE, formatMinConfidenceRequirement, meetsMinGreptileConfidence, } from "../policy/min-greptile-confidence.js";
 import { INFORMAL_CLEAN_DIAGNOSTIC } from "./constants.js";
 /** Return failure messages (empty list == merge-ready). */
-export function evaluateGates(_prNumber, headSha, verdict, inline = null) {
+export function evaluateGates(_prNumber, headSha, verdict, inline = null, options = {}) {
     const failures = [];
+    const minConfidence = options.minConfidence ?? DEFAULT_CONSUMER_MIN_GREPTILE_CONFIDENCE;
     if (!verdict.found) {
         failures.push("No Greptile rolling-summary comment found on the PR. " +
             "Either Greptile has not posted yet, or the bot login filter is wrong. " +
@@ -32,9 +34,10 @@ export function evaluateGates(_prNumber, headSha, verdict, inline = null) {
                 "Confidence is a required exit-condition input per " +
                 "skills/deft-directive-review-cycle/SKILL.md Phase 2 Step 6.");
         }
-        else if (verdict.confidence <= 3) {
-            failures.push(`Greptile confidence is ${verdict.confidence}/5; exit condition requires > 3. ` +
-                "Address remaining findings or push clarifying changes.");
+        else if (!meetsMinGreptileConfidence(verdict.confidence, minConfidence)) {
+            failures.push(`Greptile confidence is ${verdict.confidence}/5; exit condition requires ${formatMinConfidenceRequirement(minConfidence)}. ` +
+                "Address remaining findings or push clarifying changes. " +
+                "Inspect the floor via `task policy:show --field=minGreptileConfidence` (#3095).");
         }
         if (verdict.p0Count > 0 || verdict.p1Count > 0) {
             failures.push(`Greptile reports ${verdict.p0Count} P0 and ${verdict.p1Count} P1 findings ` +

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

@@ -42,5 +42,11 @@ export declare function verdictShaIsStale(verdict: GreptileVerdict, headSha: str
  * 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, inline?: InlineGreptileFindings | null): boolean;
+export declare function verdictBlockIsSoftOnly(verdict: GreptileVerdict, headSha: string | null, inline?: InlineGreptileFindings | null, 
+/**
+ * Resolved min Greptile confidence (1–5). Scores below this are HARD blockers
+ * and must never be reconciled away via GitHub CLEAN (#3095). Defaults to the
+ * consumer floor (4).
+ */
+minConfidence?: number): boolean;
 //# sourceMappingURL=mergeability.d.ts.map

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

@@ -1,3 +1,4 @@
+import { meetsMinGreptileConfidence } from "../policy/min-greptile-confidence.js";
 /** REST `mergeable_state` value that mirrors GraphQL `mergeStateStatus: CLEAN`. */
 export const MERGE_STATE_CLEAN = "clean";
 /**
@@ -75,7 +76,13 @@ export function verdictShaIsStale(verdict, headSha) {
  * regardless of GitHub mergeability (guardrail: do not merge a PR with a real
  * P0/P1 review finding).
  */
-export function verdictBlockIsSoftOnly(verdict, headSha, inline = null) {
+export function verdictBlockIsSoftOnly(verdict, headSha, inline = null, 
+/**
+ * Resolved min Greptile confidence (1–5). Scores below this are HARD blockers
+ * and must never be reconciled away via GitHub CLEAN (#3095). Defaults to the
+ * consumer floor (4).
+ */
+minConfidence = 4) {
     if (inline !== null && inline.error !== null) {
         return false;
     }
@@ -99,7 +106,12 @@ export function verdictBlockIsSoftOnly(verdict, headSha, inline = null) {
     if (verdict.errored) {
         return false;
     }
-    if (verdict.confidence !== null && verdict.confidence <= 3) {
+    // Confidence below the resolved floor is a hard blocker (#2260 / #3095).
+    // Dogfood/policy may set min=5 so a 4/5 score stays hard even when GitHub
+    // reports CLEAN + MERGEABLE. Use the shared predicate so the export is on
+    // the production call path (SLizard #3095).
+    if (verdict.confidence !== null &&
+        !meetsMinGreptileConfidence(verdict.confidence, minConfidence)) {
         return false;
     }
     if (verdict.p0Count > 0 || verdict.p1Count > 0) {

package/dist/pr-monitor/main.d.ts

@@ -5,6 +5,8 @@ export interface ParsedMonitorArgs {
     readonly repo: string | null;
     readonly capMinutes: number;
     readonly emitJson: boolean;
+    /** Project root for minGreptileConfidence (#3095 / #3102). Null = default cwd at run. */
+    readonly projectRoot: string | null;
     readonly error?: string;
 }
 export declare function parseMonitorArgs(argv: readonly string[]): ParsedMonitorArgs;

package/dist/pr-monitor/main.js

@@ -13,6 +13,7 @@ export function parseMonitorArgs(argv) {
     let repo = null;
     let capMinutes = 60;
     let emitJson = false;
+    let projectRoot = null;
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         if (arg === "--json") {
@@ -26,6 +27,7 @@ export function parseMonitorArgs(argv) {
                     repo,
                     capMinutes,
                     emitJson,
+                    projectRoot,
                     error: "argument --repo: expected one argument",
                 };
             }
@@ -35,6 +37,24 @@ export function parseMonitorArgs(argv) {
         else if (arg?.startsWith("--repo=")) {
             repo = arg.slice("--repo=".length);
         }
+        else if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    prNumber,
+                    repo,
+                    capMinutes,
+                    emitJson,
+                    projectRoot,
+                    error: "argument --project-root: expected one argument",
+                };
+            }
+            projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            projectRoot = arg.slice("--project-root=".length);
+        }
         else if (arg === "--cap-minutes") {
             const value = argv[i + 1];
             if (value === undefined) {
@@ -43,6 +63,7 @@ export function parseMonitorArgs(argv) {
                     repo,
                     capMinutes,
                     emitJson,
+                    projectRoot,
                     error: "argument --cap-minutes: expected one argument",
                 };
             }
@@ -53,6 +74,7 @@ export function parseMonitorArgs(argv) {
                     repo,
                     capMinutes,
                     emitJson,
+                    projectRoot,
                     error: `invalid --cap-minutes value: ${value}`,
                 };
             }
@@ -68,6 +90,7 @@ export function parseMonitorArgs(argv) {
                     repo,
                     capMinutes,
                     emitJson,
+                    projectRoot,
                     error: `invalid --cap-minutes value: ${value}`,
                 };
             }
@@ -79,6 +102,7 @@ export function parseMonitorArgs(argv) {
                 repo,
                 capMinutes,
                 emitJson,
+                projectRoot,
                 error: `unrecognized arguments: ${arg}`,
             };
         }
@@ -90,6 +114,7 @@ export function parseMonitorArgs(argv) {
                     repo,
                     capMinutes,
                     emitJson,
+                    projectRoot,
                     error: `invalid PR number: ${arg}`,
                 };
             }
@@ -101,6 +126,7 @@ export function parseMonitorArgs(argv) {
                 repo,
                 capMinutes,
                 emitJson,
+                projectRoot,
                 error: `unrecognized arguments: ${arg}`,
             };
         }
@@ -111,10 +137,11 @@ export function parseMonitorArgs(argv) {
             repo,
             capMinutes,
             emitJson,
+            projectRoot,
             error: "the following arguments are required: pr_number",
         };
     }
-    return { prNumber, repo, capMinutes, emitJson };
+    return { prNumber, repo, capMinutes, emitJson, projectRoot };
 }
 export function runMonitor(argv, options = {}) {
     const args = parseMonitorArgs(argv);
@@ -131,6 +158,9 @@ export function runMonitor(argv, options = {}) {
     const { exitCode, payload, pollCount } = monitorFn(args.prNumber, repo, {
         capMinutes: args.capMinutes,
         runGh: options.runGh,
+        // CLI --project-root or cwd: production remote-monitor path must not silently
+        // resolve minGreptileConfidence from an unrelated cwd (#3095 residual / #3102).
+        projectRoot: args.projectRoot ?? process.cwd(),
     });
     const summaryLabel = summaryLabelForExit(exitCode);
     const via = typeof payload.via === "string" ? payload.via : "?";

package/dist/pr-monitor/monitor.js

@@ -125,7 +125,11 @@ export function monitor(prNumber, repo, options = {}) {
     const capSeconds = (options.capMinutes ?? 60) * 60;
     const clockFn = options.clockFn ?? systemMonotonicClock;
     const sleepFn = options.sleepFn ?? defaultSleep;
-    const callReadinessFn = options.callReadinessFn ?? ((n, r) => callReadiness(n, r, { runGh: options.runGh }));
+    const callReadinessFn = options.callReadinessFn ??
+        ((n, r) => callReadiness(n, r, {
+            runGh: options.runGh,
+            projectRoot: options.projectRoot ?? process.cwd(),
+        }));
     const startedAt = clockFn.now();
     const intervalSchedule = cadenceIntervals(cadence);
     const minCadenceSec = intervalSchedule.length > 0

package/dist/pr-monitor/readiness.js

@@ -27,7 +27,9 @@ export function callReadiness(prNumber, repo, options = {}) {
     try {
         process.stderr.write = captureWrite;
         const runGh = options.runGh ?? defaultRunGh;
-        const result = computeGateResult(prNumber, repo, runGh);
+        const result = computeGateResult(prNumber, repo, runGh, {
+            projectRoot: options.projectRoot ?? process.cwd(),
+        });
         const payload = gateResultToDict(result);
         const exitCode = exitCodeFor(result);
         return {

package/dist/pr-monitor/types.d.ts

@@ -17,6 +17,12 @@ export interface MonitorOptions {
     readonly clockFn?: MonotonicClock;
     readonly callReadinessFn?: CallReadinessFn;
     readonly runGh?: RunGhFn;
+    /**
+     * Project root for plan.policy.review.minGreptileConfidence (#3095).
+     * When pr-monitor targets a remote repo from a different cwd, pass the
+     * monitored project's root so confidence policy is not resolved from cwd.
+     */
+    readonly projectRoot?: string | null;
 }
 export interface MonitorRunResult {
     readonly exitCode: number;
@@ -26,5 +32,7 @@ export interface MonitorRunResult {
 export interface CallReadinessOptions {
     readonly runGh?: RunGhFn;
     readonly timeoutMs?: number;
+    /** Project root for minGreptileConfidence resolve (#3095). */
+    readonly projectRoot?: string | null;
 }
 //# sourceMappingURL=types.d.ts.map

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

@@ -1,6 +1,8 @@
 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";
+/** Post-merge umbrella checklist + current-shape refresh (#1649). */
+export type UmbrellaReconcileFn = (projectRoot: string, repo: string) => void;
 export interface WaitMergeableOptions {
     readonly protectedFn?: ProtectedCheckFn;
     readonly monitorFn?: MonitorFn;
@@ -21,6 +23,12 @@ export interface WaitMergeableOptions {
     readonly agentMergeFn?: (projectRoot: string) => AgentMergeEvaluateResult;
     /** When true, skip human-merge / intent preflight (tests only). */
     readonly skipHumanMergeGate?: boolean;
+    /**
+     * Post-merge umbrella reconcile (#1649). Defaults to live reconcileUmbrellas.
+     * Pass `null` to skip (unit tests that inject mergeFn must pass null so they
+     * never mutate real GitHub current-shape comments from the worktree cwd).
+     */
+    readonly umbrellaReconcileFn?: UmbrellaReconcileFn | null;
 }
 /** Run protected-check -> wait -> merge cascade (#1369). */
 export declare function waitMergeableAndMerge(prNumber: number, repo: string, options: {