@deftai/directive-core 0.93.0 → 0.94.0

package/dist/hooks/readonly.d.ts

@@ -1,7 +1,21 @@
+/** Session posture env for assist/research low-ceremony writes (#1802). */
+export declare const ASSIST_SESSION_POSTURE_ENV = "DEFT_SESSION_POSTURE";
 /** Best-effort read-only explore signal from host payload (#1185). */
 export declare function hookReadOnlyFromPayload(payload: unknown): boolean;
 /** Read-only hook context: env override or host payload marker (#1185). */
 export declare function isReadOnlyHookContext(payload: unknown, environ?: NodeJS.ProcessEnv): boolean;
 /** Explore sub-agent spawns are exempt from the implementation gate stack (#1185). */
 export declare function isExploreSpawn(payload: unknown): boolean;
+/**
+ * Assist / research / ephemeral session posture for low-ceremony scratch writes (#1802).
+ * Structural markers only (env, payload posture fields, worker_role/subagent_type).
+ * Absent marker → false (fail closed). Compose with allowlisted scratch path fence.
+ */
+export declare function isAssistPosture(payload: unknown, environ?: NodeJS.ProcessEnv): boolean;
+/**
+ * Ephemeral / assist / docs spawns skip active-xBRIEF implementation gates (#3080).
+ * True only with an explicit allowlisted marker. Absent marker → false (fail closed).
+ * When an ephemeral marker conflicts with implement envelope signals, implement wins.
+ */
+export declare function isEphemeralSpawn(payload: unknown): boolean;
 //# sourceMappingURL=readonly.d.ts.map

package/dist/hooks/readonly.js

@@ -1,5 +1,19 @@
 import { READ_ONLY_HOOK_ENV } from "./tools.js";
 const TRUTHY = new Set(["1", "true", "yes", "on"]);
+/** Session posture env for assist/research low-ceremony writes (#1802). */
+export const ASSIST_SESSION_POSTURE_ENV = "DEFT_SESSION_POSTURE";
+/** Explicit non-lifecycle assist markers (#3080 / #1802). Primary: ephemeral; aliases: docs, assist. */
+const EPHEMERAL_ROLE_MARKERS = new Set(["ephemeral", "docs", "assist"]);
+/** Assist/research session posture tokens (structural; not free-text NLP) (#1802). */
+const ASSIST_POSTURE_MARKERS = new Set([
+    "assist",
+    "ephemeral",
+    "docs",
+    "research",
+    "research-notes",
+    "research_notes",
+    "scratch",
+]);
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -28,6 +42,9 @@ function isReadOnlyCapability(value) {
     const normalized = value.toLowerCase().replace(/[_\s-]/g, "");
     return normalized === "readonly";
 }
+function normalizePostureToken(value) {
+    return value.toLowerCase().replace(/[_\s]/g, "-");
+}
 /** Best-effort read-only explore signal from host payload (#1185). */
 export function hookReadOnlyFromPayload(payload) {
     const input = record(payload);
@@ -80,4 +97,113 @@ export function isExploreSpawn(payload) {
         fieldString(input, "workerRole");
     return workerRole?.toLowerCase() === "explore";
 }
+/**
+ * Assist / research / ephemeral session posture for low-ceremony scratch writes (#1802).
+ * Structural markers only (env, payload posture fields, worker_role/subagent_type).
+ * Absent marker → false (fail closed). Compose with allowlisted scratch path fence.
+ */
+export function isAssistPosture(payload, environ = process.env) {
+    const envPosture = (environ[ASSIST_SESSION_POSTURE_ENV] ?? "").trim();
+    if (envPosture.length > 0 && ASSIST_POSTURE_MARKERS.has(normalizePostureToken(envPosture))) {
+        return true;
+    }
+    // Explicit assist env override (truthy), separate from posture token names.
+    if (envTruthy(environ, "DEFT_HOOK_ASSIST"))
+        return true;
+    const input = record(payload);
+    if (input === null)
+        return false;
+    const toolInput = toolInputRecord(input) ?? input;
+    const posture = fieldString(toolInput, "posture") ??
+        fieldString(toolInput, "session_posture") ??
+        fieldString(toolInput, "sessionPosture") ??
+        fieldString(input, "posture") ??
+        fieldString(input, "session_posture") ??
+        fieldString(input, "sessionPosture");
+    if (posture !== null && ASSIST_POSTURE_MARKERS.has(normalizePostureToken(posture))) {
+        return true;
+    }
+    // Shared taxonomy with #3080 ephemeral spawn markers.
+    if (isEphemeralSpawn(payload))
+        return true;
+    return false;
+}
+/**
+ * Structural implement signals that win over an ephemeral marker (fail closed, #3080).
+ * Detected from envelope fields only — never free-text prompt heuristics.
+ */
+function hasImplementConflictSignal(toolInput, input) {
+    const driveTo = fieldString(toolInput, "drive_to") ??
+        fieldString(toolInput, "driveTo") ??
+        fieldString(toolInput, "drive-to") ??
+        fieldString(input, "drive_to") ??
+        fieldString(input, "driveTo") ??
+        fieldString(input, "drive-to");
+    if (driveTo !== null) {
+        const normalized = driveTo.toLowerCase().replace(/[_\s]/g, "-");
+        if (normalized === "merge-ready" ||
+            normalized === "merge" ||
+            normalized.startsWith("merge-") ||
+            normalized.includes("implement")) {
+            return true;
+        }
+    }
+    // Non-ephemeral worker roles that imply product implementation / swarm leaf.
+    // Skip when this field is itself the ephemeral marker (conflict is via other fields).
+    const workerRole = fieldString(toolInput, "worker_role") ??
+        fieldString(toolInput, "workerRole") ??
+        fieldString(input, "worker_role") ??
+        fieldString(input, "workerRole");
+    if (workerRole !== null && !EPHEMERAL_ROLE_MARKERS.has(workerRole.toLowerCase())) {
+        const role = workerRole.toLowerCase().replace(/[_\s]/g, "-");
+        if (role === "leaf-implementation" ||
+            role === "implementation" ||
+            role === "implement" ||
+            role.includes("implement")) {
+            return true;
+        }
+    }
+    const dispatchKind = fieldString(toolInput, "dispatch_kind") ??
+        fieldString(toolInput, "dispatchKind") ??
+        fieldString(input, "dispatch_kind") ??
+        fieldString(input, "dispatchKind");
+    if (dispatchKind !== null) {
+        const kind = dispatchKind.toLowerCase().replace(/[_\s]/g, "-");
+        if (kind === "swarm-cohort" || kind === "swarm-leaf" || kind.includes("implement")) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Ephemeral / assist / docs spawns skip active-xBRIEF implementation gates (#3080).
+ * True only with an explicit allowlisted marker. Absent marker → false (fail closed).
+ * When an ephemeral marker conflicts with implement envelope signals, implement wins.
+ */
+export function isEphemeralSpawn(payload) {
+    const input = record(payload);
+    if (input === null)
+        return false;
+    const toolInput = toolInputRecord(input) ?? input;
+    const subagentType = fieldString(toolInput, "subagent_type") ??
+        fieldString(toolInput, "subagentType") ??
+        fieldString(input, "subagent_type") ??
+        fieldString(input, "subagentType");
+    const workerRole = fieldString(toolInput, "worker_role") ??
+        fieldString(toolInput, "workerRole") ??
+        fieldString(input, "worker_role") ??
+        fieldString(input, "workerRole");
+    const marker = (workerRole !== null && EPHEMERAL_ROLE_MARKERS.has(workerRole.toLowerCase())
+        ? workerRole.toLowerCase()
+        : null) ??
+        (subagentType !== null && EPHEMERAL_ROLE_MARKERS.has(subagentType.toLowerCase())
+            ? subagentType.toLowerCase()
+            : null);
+    if (marker === null)
+        return false;
+    // Implement signals win over ephemeral markers (fail closed).
+    if (hasImplementConflictSignal(toolInput, input))
+        return false;
+    return true;
+}
 //# sourceMappingURL=readonly.js.map

package/dist/intake/issue-ingest.d.ts

@@ -1,6 +1,9 @@
 import { type ScanFlag } from "../cache/scanner.js";
+import { type IssueComment as ShapeIssueComment } from "../umbrella-current-shape/index.js";
 import { LEGACY_ARTIFACT_SUFFIX, LEGACY_INFO_ROOT_KEY, MIGRATED_ARTIFACT_SUFFIX, MIGRATED_INFO_ROOT_KEY } from "../xbrief-migrate/constants.js";
 import { type ScmCallFn } from "./reconcile-issues.js";
+/** Reference type pointing at the canonical current-shape comment permalink (#1870). */
+export declare const CURRENT_SHAPE_REF_TYPE: "x-xbrief/current-shape";
 export declare const INGEST_STATUSES: readonly ["proposed", "pending", "active"];
 export type IngestStatus = (typeof INGEST_STATUSES)[number];
 /**
@@ -21,9 +24,26 @@ export interface IssueComment {
         readonly login?: string;
     };
     readonly created_at?: string;
+    readonly updated_at?: string;
+    readonly html_url?: string;
+    readonly author_association?: string;
 }
 /** Enriched on issues after `fetchIssue` when the comment thread is non-empty (#2143). */
 export declare const ISSUE_COMMENT_THREAD_KEY: "issueCommentThread";
+/**
+ * Map ingest/REST comment rows onto the umbrella-current-shape selector input
+ * so #1152 pass-N + #2307 maintainer provenance rules apply (#1870).
+ */
+export declare function mapIngestCommentsToShapeComments(comments: readonly IssueComment[]): ShapeIssueComment[];
+/**
+ * Select the canonical current-shape comment from an ingest comment thread.
+ * Returns null when none is maintainer-authored / header-matched.
+ */
+export declare function selectIngestCurrentShape(comments: readonly IssueComment[]): (ShapeIssueComment & {
+    pass: number;
+}) | null;
+/** Count maintainer current-shape comments (lint surface for !=1). */
+export declare function countIngestCurrentShapeComments(comments: readonly IssueComment[]): number;
 export declare function bodyControlCharacterLabels(body: string): string[];
 export declare function warnBodyControlCharacters(number: number, body: string): void;
 export declare function extractPlanItems(body: string): Record<string, string>[];

package/dist/intake/issue-ingest.js

@@ -7,11 +7,14 @@ import { hasArtifactSuffix, resolveLifecycleRoot } from "../layout/resolve.js";
 import { call } from "../scm/call.js";
 import { resolveProjectRoot } from "../scope/project-context.js";
 import { resolveProjectRepo } from "../slice/project-context.js";
+import { countMaintainerCurrentShapeComments, mapIssueCommentEntry, RAW_ISSUE_COMMENTS_KEY, selectCurrentShapeComment, } from "../umbrella-current-shape/index.js";
 import { slugify, TODAY } from "../vbrief-build/build.js";
 import { EMITTED_VBRIEF_VERSION } from "../vbrief-build/constants.js";
 import { LEGACY_ARTIFACT_SUFFIX, LEGACY_INFO_ROOT_KEY, MIGRATED_ARTIFACT_DIR, MIGRATED_ARTIFACT_SUFFIX, MIGRATED_INFO_ROOT_KEY, VBRIEF_VERSION, } from "../xbrief-migrate/constants.js";
 import { findAcHeading, parseCheckboxItems, parseListItems, sliceAcSection, stripCodeBlocks, stripFencedCodeBlocks, } from "./markdown-scanners.js";
 import { detectRepo, extractReferencesFromVbrief, fetchOpenIssues, GITHUB_ISSUE_REF_TYPES, LIFECYCLE_FOLDERS, parseIssueNumber, } from "./reconcile-issues.js";
+/** Reference type pointing at the canonical current-shape comment permalink (#1870). */
+export const CURRENT_SHAPE_REF_TYPE = "x-xbrief/current-shape";
 export const INGEST_STATUSES = ["proposed", "pending", "active"];
 /**
  * Thrown when the quarantine scanner hard-fails (credential-shaped content) on
@@ -36,6 +39,31 @@ export class ScannerHardFailError extends Error {
 }
 /** Enriched on issues after `fetchIssue` when the comment thread is non-empty (#2143). */
 export const ISSUE_COMMENT_THREAD_KEY = "issueCommentThread";
+/**
+ * Map ingest/REST comment rows onto the umbrella-current-shape selector input
+ * so #1152 pass-N + #2307 maintainer provenance rules apply (#1870).
+ */
+export function mapIngestCommentsToShapeComments(comments) {
+    const out = [];
+    for (const comment of comments) {
+        const mapped = mapIssueCommentEntry(comment);
+        if (mapped !== null) {
+            out.push(mapped);
+        }
+    }
+    return out;
+}
+/**
+ * Select the canonical current-shape comment from an ingest comment thread.
+ * Returns null when none is maintainer-authored / header-matched.
+ */
+export function selectIngestCurrentShape(comments) {
+    return selectCurrentShapeComment(mapIngestCommentsToShapeComments(comments));
+}
+/** Count maintainer current-shape comments (lint surface for !=1). */
+export function countIngestCurrentShapeComments(comments) {
+    return countMaintainerCurrentShapeComments(mapIngestCommentsToShapeComments(comments));
+}
 const STATUS_MAP = {
     proposed: ["proposed", "proposed"],
     pending: ["pending", "pending"],
@@ -326,6 +354,11 @@ export function buildIssueVbrief(issue, status, repoUrl, options = {}) {
     const bodyStr = typeof bodyRaw === "string" && bodyRaw.length > 0 ? bodyRaw : "";
     const commentThread = issueCommentThread(issue);
     const overviewSource = commentThread.length > 0 ? composeOverviewWithComments(bodyStr, commentThread) : bodyStr;
+    // #1870 / #1152: materialize the canonical Current shape comment as its own
+    // narrative so agents cannot plan umbrellas from the stale body alone. Prefer
+    // the same selector as `task umbrella:current-shape` (highest pass-N,
+    // maintainer-authored only — #2307).
+    const currentShape = selectIngestCurrentShape(commentThread);
     const labelsRaw = issue.labels;
     const labelNames = [];
     if (Array.isArray(labelsRaw)) {
@@ -366,6 +399,10 @@ export function buildIssueVbrief(issue, status, repoUrl, options = {}) {
         }
         narratives.Overview = scanResult.transformed_content;
     }
+    if (currentShape !== null) {
+        // Scan shape body under the same fail-closed contract as Overview (#2306).
+        narratives.CurrentShape = scanUntrustedIngestText(number, currentShape.body);
+    }
     if (labelNames.length > 0) {
         narratives.Labels = labelNames.join(", ");
     }
@@ -392,6 +429,16 @@ export function buildIssueVbrief(issue, status, repoUrl, options = {}) {
                 title: `Issue #${number}: ${title}`,
             },
         ];
+        if (currentShape !== null) {
+            const shapeUri = currentShape.htmlUrl.length > 0
+                ? currentShape.htmlUrl
+                : `${url}#issuecomment-${currentShape.id}`;
+            references.push({
+                uri: shapeUri,
+                type: CURRENT_SHAPE_REF_TYPE,
+                title: `Current shape (pass-${currentShape.pass}) for #${number}`,
+            });
+        }
         if (overviewSource.length > 0 && repoUrl.length > 0) {
             references.push(...extractCrossRefs(overviewSource, repoUrl, new Set([number])));
         }
@@ -446,6 +493,12 @@ export function fetchFromCache(repo, number, options = {}) {
         // the quarantine transform. When content.md is absent (e.g. a credential
         // hard-fail deleted it), the raw body falls through and is re-scanned in
         // buildIssueVbrief.
+        //
+        // #1870 note: content.md may also include the appended Canonical current
+        // shape section. That is intentional for agent-facing cache reads. When
+        // raw.comments is present we also restore the comment thread so
+        // narratives.CurrentShape + the current-shape reference can be materialised
+        // offline (without a live comments fetch).
         if (result.contentPath !== null) {
             try {
                 // #2314: content.md is `renderContent`-prefixed with a `# #<n>: <title>`
@@ -458,6 +511,11 @@ export function fetchFromCache(repo, number, options = {}) {
                 // fall back to the raw body (re-scanned downstream)
             }
         }
+        // #1870: restore comment thread from cache raw so CurrentShape survives
+        // offline / no-live-gh paths (fetchIssue still prefers live comments).
+        if (!issueCommentsAlreadyFetched(issue) && Array.isArray(issue[RAW_ISSUE_COMMENTS_KEY])) {
+            return attachIssueCommentThread(issue, issue[RAW_ISSUE_COMMENTS_KEY]);
+        }
         return issue;
     }
     catch {

package/dist/policy/index.d.ts

@@ -9,6 +9,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";

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";
@@ -340,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,
@@ -353,6 +364,7 @@ const REGISTERED_POLICIES = [
     }),
     inspectSwarmSubagentBackend,
     inspectDeliveryBranchField,
+    inspectMinGreptileConfidenceField,
     inspectHostHooksField,
     inspectHostSlashCommandsField,
     inspectOpenClawProductCommandsField,
@@ -393,7 +405,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