@deftai/directive-core 0.92.0 → 0.94.0

package/dist/policy/host-slash-commands.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Per-host slash-command deposit policy (#3054 / epic #55 L6).
+ *
+ * Parallel to {@link plan.policy.hostHooks}: default multi-host enablement for
+ * every host that has a real emitter (no stubs). Per-host `false` opts out.
+ */
+import { type SlashEmitterHostId } from "../slash/emitters.js";
+export declare const FIELD_HOST_SLASH_COMMANDS = "plan.policy.hostSlashCommands";
+export declare const FIELD_HOST_SLASH_COMMANDS_CLI_ALIAS = "hostSlashCommands";
+/** Per-host Directive slash-command deposit toggles (#3054). */
+export type HostSlashCommandsPolicy = Record<SlashEmitterHostId, boolean>;
+/** Default = all hosts with real emitters enabled (L6; not single-host-only). */
+export declare const DEFAULT_HOST_SLASH_COMMANDS_POLICY: HostSlashCommandsPolicy;
+export interface HostSlashCommandsPolicyField {
+    readonly name: string;
+    readonly current: HostSlashCommandsPolicy;
+    readonly default: HostSlashCommandsPolicy;
+    readonly source: string;
+}
+/** Resolve typed slash-command deposit policy from raw PROJECT-DEFINITION value. */
+export declare function resolveHostSlashCommandsPolicy(raw: unknown): HostSlashCommandsPolicy;
+export declare function validateHostSlashCommands(value: unknown): string[];
+export declare function isHostSlashCommandDepositEnabled(host: SlashEmitterHostId, policy?: HostSlashCommandsPolicy): boolean;
+/** Inspector row for `policy:show --field=hostSlashCommands`. */
+export declare function inspectHostSlashCommands(data: Record<string, unknown> | null): HostSlashCommandsPolicyField;
+/** Resolve slash-command deposit policy from PROJECT-DEFINITION on disk. */
+export declare function loadHostSlashCommandsPolicyFromProject(projectRoot: string): HostSlashCommandsPolicy;
+//# sourceMappingURL=host-slash-commands.d.ts.map

package/dist/policy/host-slash-commands.js

@@ -0,0 +1,103 @@
+/**
+ * Per-host slash-command deposit policy (#3054 / epic #55 L6).
+ *
+ * Parallel to {@link plan.policy.hostHooks}: default multi-host enablement for
+ * every host that has a real emitter (no stubs). Per-host `false` opts out.
+ */
+import { isSlashEmitterHostId, SLASH_EMITTER_HOSTS, } from "../slash/emitters.js";
+import { readPlanPolicy } from "./plan-extensions.js";
+import { loadProjectDefinition } from "./resolve.js";
+export const FIELD_HOST_SLASH_COMMANDS = "plan.policy.hostSlashCommands";
+export const FIELD_HOST_SLASH_COMMANDS_CLI_ALIAS = "hostSlashCommands";
+/** Default = all hosts with real emitters enabled (L6; not single-host-only). */
+export const DEFAULT_HOST_SLASH_COMMANDS_POLICY = Object.freeze({
+    claude: true,
+    cursor: true,
+    grok: true,
+    codex: true,
+});
+function readHostBoolean(rec, host, fallback) {
+    if (host in rec && typeof rec[host] === "boolean") {
+        return rec[host];
+    }
+    return fallback;
+}
+/** Resolve typed slash-command deposit policy from raw PROJECT-DEFINITION value. */
+export function resolveHostSlashCommandsPolicy(raw) {
+    if (raw === null || raw === undefined) {
+        return { ...DEFAULT_HOST_SLASH_COMMANDS_POLICY };
+    }
+    if (typeof raw !== "object" || Array.isArray(raw)) {
+        return { ...DEFAULT_HOST_SLASH_COMMANDS_POLICY };
+    }
+    const rec = raw;
+    return {
+        claude: readHostBoolean(rec, "claude", DEFAULT_HOST_SLASH_COMMANDS_POLICY.claude),
+        cursor: readHostBoolean(rec, "cursor", DEFAULT_HOST_SLASH_COMMANDS_POLICY.cursor),
+        grok: readHostBoolean(rec, "grok", DEFAULT_HOST_SLASH_COMMANDS_POLICY.grok),
+        codex: readHostBoolean(rec, "codex", DEFAULT_HOST_SLASH_COMMANDS_POLICY.codex),
+    };
+}
+export function validateHostSlashCommands(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        return [`${FIELD_HOST_SLASH_COMMANDS} must be an object; got ${typeof value}`];
+    }
+    const rec = value;
+    const errors = [];
+    for (const host of SLASH_EMITTER_HOSTS) {
+        if (host in rec && typeof rec[host] !== "boolean") {
+            errors.push(`${FIELD_HOST_SLASH_COMMANDS}.${host} must be a boolean`);
+        }
+    }
+    for (const key of Object.keys(rec)) {
+        if (!isSlashEmitterHostId(key)) {
+            errors.push(`${FIELD_HOST_SLASH_COMMANDS}.${key} is not a slash emitter host (${SLASH_EMITTER_HOSTS.join(", ")})`);
+        }
+    }
+    return errors;
+}
+export function isHostSlashCommandDepositEnabled(host, policy = DEFAULT_HOST_SLASH_COMMANDS_POLICY) {
+    return policy[host];
+}
+function fieldFromResolved(resolved, source) {
+    return {
+        name: FIELD_HOST_SLASH_COMMANDS,
+        current: resolved,
+        default: { ...DEFAULT_HOST_SLASH_COMMANDS_POLICY },
+        source,
+    };
+}
+/** Inspector row for `policy:show --field=hostSlashCommands`. */
+export function inspectHostSlashCommands(data) {
+    if (data === null) {
+        return fieldFromResolved({ ...DEFAULT_HOST_SLASH_COMMANDS_POLICY }, "default");
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("hostSlashCommands" in policyBlock)) {
+        return fieldFromResolved({ ...DEFAULT_HOST_SLASH_COMMANDS_POLICY }, "default");
+    }
+    const resolved = resolveHostSlashCommandsPolicy(policyBlock.hostSlashCommands);
+    return fieldFromResolved(resolved, "typed");
+}
+/** Resolve slash-command deposit policy from PROJECT-DEFINITION on disk. */
+export function loadHostSlashCommandsPolicyFromProject(projectRoot) {
+    const [data] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return { ...DEFAULT_HOST_SLASH_COMMANDS_POLICY };
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("hostSlashCommands" in policyBlock)) {
+        return { ...DEFAULT_HOST_SLASH_COMMANDS_POLICY };
+    }
+    return resolveHostSlashCommandsPolicy(policyBlock.hostSlashCommands);
+}
+//# sourceMappingURL=host-slash-commands.js.map

package/dist/policy/index.d.ts

@@ -6,8 +6,10 @@ export * from "./deft-directive-disable.js";
 export * from "./delivery-branch.js";
 export * from "./disclosure.js";
 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";

package/dist/policy/index.js

@@ -1,6 +1,10 @@
+import { FIELD_HOST_SKILL_DISCOVERY, FIELD_HOST_SKILL_DISCOVERY_CLI_ALIAS, inspectHostSkillDiscovery, } from "../init-deposit/skill-discovery-hosts.js";
+import { FIELD_OPENCLAW_PRODUCT_COMMANDS, FIELD_OPENCLAW_PRODUCT_COMMANDS_CLI_ALIAS, inspectOpenClawProductCommands, } from "../slash/openclaw-deposit.js";
 import { FIELD_DELIVERY_BRANCH, FIELD_DELIVERY_BRANCH_CLI_ALIAS, inspectDeliveryBranch, } from "./delivery-branch.js";
 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";
@@ -17,8 +21,10 @@ export * from "./deft-directive-disable.js";
 export * from "./delivery-branch.js";
 export * from "./disclosure.js";
 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";
@@ -282,6 +288,33 @@ function inspectHostHooksField(data) {
         source: field.source,
     };
 }
+function inspectHostSlashCommandsField(data) {
+    const field = inspectHostSlashCommands(data);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
+function inspectOpenClawProductCommandsField(data) {
+    const field = inspectOpenClawProductCommands(data);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
+function inspectHostSkillDiscoveryField(data) {
+    const field = inspectHostSkillDiscovery(data);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 function inspectRequireHumanMergeField(data, projectRoot) {
     const field = inspectRequireHumanMerge(data, projectRoot);
     return {
@@ -309,6 +342,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,
@@ -322,7 +364,11 @@ const REGISTERED_POLICIES = [
     }),
     inspectSwarmSubagentBackend,
     inspectDeliveryBranchField,
+    inspectMinGreptileConfidenceField,
     inspectHostHooksField,
+    inspectHostSlashCommandsField,
+    inspectOpenClawProductCommandsField,
+    inspectHostSkillDiscoveryField,
     inspectStalenessTicklerField,
     inspectRuntimeAuthorityField,
     inspectProductSignalField,
@@ -347,13 +393,21 @@ export function inspectOnePolicy(name, projectRoot) {
                     ? FIELD_RUNTIME_AUTHORITY
                     : name === FIELD_HOST_HOOKS_CLI_ALIAS
                         ? FIELD_HOST_HOOKS
-                        : name === FIELD_REQUIRE_HUMAN_MERGE_CLI_ALIAS
-                            ? FIELD_REQUIRE_HUMAN_MERGE
-                            : name === FIELD_HOTFIX_CRITERIA_CLI_ALIAS
-                                ? FIELD_HOTFIX_CRITERIA
-                                : name === FIELD_DELIVERY_BRANCH_CLI_ALIAS
-                                    ? FIELD_DELIVERY_BRANCH
-                                    : name;
+                        : name === FIELD_HOST_SLASH_COMMANDS_CLI_ALIAS
+                            ? FIELD_HOST_SLASH_COMMANDS
+                            : name === FIELD_OPENCLAW_PRODUCT_COMMANDS_CLI_ALIAS
+                                ? FIELD_OPENCLAW_PRODUCT_COMMANDS
+                                : name === FIELD_HOST_SKILL_DISCOVERY_CLI_ALIAS
+                                    ? FIELD_HOST_SKILL_DISCOVERY
+                                    : name === FIELD_REQUIRE_HUMAN_MERGE_CLI_ALIAS
+                                        ? FIELD_REQUIRE_HUMAN_MERGE
+                                        : name === FIELD_HOTFIX_CRITERIA_CLI_ALIAS
+                                            ? FIELD_HOTFIX_CRITERIA
+                                            : name === FIELD_DELIVERY_BRANCH_CLI_ALIAS
+                                                ? FIELD_DELIVERY_BRANCH
+                                                : 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;