@deftai/directive-core 0.90.0 → 0.92.0

package/dist/policy/deft-directive-disable.js

@@ -0,0 +1,167 @@
+/**
+ * Temporary test/local kill-switch for Directive enforcement (#3039).
+ *
+ * Presence of root `.deft-directive-disable` means Directive **enforcement** is
+ * OFF (hooks, session ritual, automation) while the deposit may remain — **only
+ * when the file is not tracked by git**. A committed flag is misconfig: doctor
+ * warns and enforcement stays ON (repository-controlled content must not disable
+ * hooks for downstream clones).
+ *
+ * Distinct from `.no-deft-directive` (#2926 permanent opt-out): flag+deposit is
+ * **not** inconsistent here.
+ *
+ * Product choices (v1):
+ * - Flag is **root-only** (workspace root the tool opened).
+ * - Flag **must be gitignored** (canonical baseline); committed flag → doctor
+ *   warns and does **not** short-circuit enforcement.
+ * - Deposit presence is **OK**.
+ * - Full re-enable requires: delete the file **and** start a **new** agent session.
+ * - Precedence: active kill-switch first, then `.no-deft-directive`, else normal.
+ */
+import { execFileSync } from "node:child_process";
+import { statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { CANONICAL_INSTALL_ROOT } from "../init-deposit/constants.js";
+/** Canonical root-only filename (lowercase). Presence = candidate flag. */
+export const DEFT_DIRECTIVE_DISABLE_FLAG_NAME = ".deft-directive-disable";
+/** Gitignore entry the deposit must ensure (same as flag name). */
+export const DEFT_DIRECTIVE_DISABLE_GITIGNORE_LINE = DEFT_DIRECTIVE_DISABLE_FLAG_NAME;
+/**
+ * Canonical recovery message when Directive is disabled by the test kill-switch.
+ * Surfaces (doctor, agent, CLI, hooks) share this wording.
+ */
+export const DEFT_DIRECTIVE_DISABLE_RECOVERY_MESSAGE = "Directive is DISABLED for this project via root `.deft-directive-disable` (test/local kill-switch).\n" +
+    "Deposit may still be present; enforcement (hooks, session ritual, automation) will not run.\n" +
+    "\n" +
+    "To fully re-enable Directive:\n" +
+    "  1. Delete the file:  rm .deft-directive-disable   (or equivalent)\n" +
+    "  2. Start a NEW agent session (reload AGENTS / host skills / hooks)\n" +
+    "Until both are done, Directive is not fully operational.";
+/** One-line summary for log lines and short CLI output. */
+export const DEFT_DIRECTIVE_DISABLE_ONE_LINE = "Directive disabled via `.deft-directive-disable` (test/local kill-switch; deposit OK)";
+/** Doctor/status label when the kill-switch is active (local / untracked). */
+export const DEFT_DIRECTIVE_DISABLE_STATUS = "disabled-test-kill-switch";
+/**
+ * Warning when the kill-switch file is tracked by git (should be gitignored).
+ * Tracked flags do **not** disable enforcement.
+ */
+export const DEFT_DIRECTIVE_DISABLE_TRACKED_WARNING = "Misconfig: `.deft-directive-disable` is tracked by git. The flag must be gitignored (local kill-switch only). Untrack it and ensure `.gitignore` covers the path. Enforcement is NOT disabled while the flag is tracked.";
+/** Cap git probe so hot-path hooks never hang on a slow VCS call. */
+const GIT_TRACKED_PROBE_TIMEOUT_MS = 1500;
+/** Process-local cache: avoid re-spawning git on every PreToolUse while the flag is present. */
+const trackedProbeCache = new Map();
+const TRACKED_PROBE_CACHE_TTL_MS = 30_000;
+function defaultIsFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function defaultIsDir(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function defaultIsGitTracked(projectRoot, relPath) {
+    const cacheKey = `${projectRoot}\0${relPath}`;
+    const now = Date.now();
+    const cached = trackedProbeCache.get(cacheKey);
+    if (cached !== undefined && now - cached.atMs < TRACKED_PROBE_CACHE_TTL_MS) {
+        return cached.tracked;
+    }
+    let tracked = false;
+    try {
+        const out = execFileSync("git", ["ls-files", "--", relPath], {
+            cwd: projectRoot,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: GIT_TRACKED_PROBE_TIMEOUT_MS,
+        });
+        tracked = out.trim().length > 0;
+    }
+    catch {
+        tracked = false;
+    }
+    trackedProbeCache.set(cacheKey, { tracked, atMs: now });
+    return tracked;
+}
+/** Absolute path to the root kill-switch flag file. */
+export function deftDirectiveDisableFlagPath(projectRoot) {
+    return resolve(projectRoot, DEFT_DIRECTIVE_DISABLE_FLAG_NAME);
+}
+/**
+ * Detect root `.deft-directive-disable`. Presence is file-existence only
+ * (empty or short comment OK). Deposit presence is reported but never treated
+ * as inconsistent (#3039 vs #2926).
+ *
+ * Enforcement short-circuit uses `state.active` (present && !trackedByGit).
+ */
+export function detectDeftDirectiveDisable(projectRoot, seams = {}) {
+    const flagPath = deftDirectiveDisableFlagPath(projectRoot);
+    const isFile = seams.isFile ?? defaultIsFile;
+    const isDir = seams.isDir ?? defaultIsDir;
+    const isGitTracked = seams.isGitTracked ?? defaultIsGitTracked;
+    const present = isFile(flagPath);
+    const depositPresent = isDir(join(projectRoot, CANONICAL_INSTALL_ROOT));
+    let trackedByGit = false;
+    if (present) {
+        if (seams.skipTrackedCache && seams.isGitTracked === undefined) {
+            // Fresh probe without reading process cache (doctor / one-shot CLI).
+            try {
+                const out = execFileSync("git", ["ls-files", "--", DEFT_DIRECTIVE_DISABLE_FLAG_NAME], {
+                    cwd: projectRoot,
+                    encoding: "utf8",
+                    stdio: ["ignore", "pipe", "ignore"],
+                    timeout: GIT_TRACKED_PROBE_TIMEOUT_MS,
+                });
+                trackedByGit = out.trim().length > 0;
+            }
+            catch {
+                trackedByGit = false;
+            }
+        }
+        else {
+            trackedByGit = isGitTracked(projectRoot, DEFT_DIRECTIVE_DISABLE_FLAG_NAME);
+        }
+    }
+    return {
+        present,
+        flagPath,
+        depositPresent,
+        trackedByGit,
+        active: present && !trackedByGit,
+    };
+}
+/**
+ * True when the local (untracked) kill-switch is active for enforcement
+ * short-circuit. Tracked flags return false so hooks stay enforced.
+ */
+export function isDeftDirectiveDisableActive(projectRoot, seams = {}) {
+    return detectDeftDirectiveDisable(projectRoot, seams).active;
+}
+/**
+ * Full operator-facing message for the kill-switch, optionally combined with
+ * permanent opt-out when both flags are present.
+ */
+export function formatDeftDirectiveDisableMessage(options = {}) {
+    const parts = [];
+    if (options.oneLine) {
+        parts.push(DEFT_DIRECTIVE_DISABLE_ONE_LINE);
+    }
+    else {
+        parts.push(DEFT_DIRECTIVE_DISABLE_RECOVERY_MESSAGE);
+    }
+    if (options.permanentOptOutAlsoPresent) {
+        parts.push("Also present: root `.no-deft-directive` (permanent opt-out). Install/update fail-closed semantics still apply for that flag.");
+    }
+    if (options.trackedByGit) {
+        parts.push(DEFT_DIRECTIVE_DISABLE_TRACKED_WARNING);
+    }
+    return parts.join("\n\n");
+}
+//# sourceMappingURL=deft-directive-disable.js.map

package/dist/policy/delivery-branch.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Typed plan.policy.deliveryBranch (#3041).
+ *
+ * Distinct from swarm/PR `baseBranch` (integration target for PRs / finalize
+ * sweep PRs). deliveryBranch is where shipped work must land for a delivered
+ * completion disposition.
+ */
+import { type GitRunner } from "../session/git.js";
+export declare const FIELD_DELIVERY_BRANCH = "plan.policy.deliveryBranch";
+export declare const FIELD_DELIVERY_BRANCH_CLI_ALIAS = "deliveryBranch";
+/** Framework fallback when neither policy nor git default can be resolved. */
+export declare const DEFAULT_DELIVERY_BRANCH_FALLBACK = "master";
+export type DeliveryBranchSource = "typed" | "git-default" | "default-fallback" | "default-on-error";
+export interface DeliveryBranchResult {
+    readonly branch: string;
+    readonly source: DeliveryBranchSource;
+    readonly error: string | null;
+}
+/**
+ * Resolve the project's delivery branch (#3041).
+ *
+ * Order: typed plan.policy.deliveryBranch → git remote default → local main/master → "master".
+ */
+export declare function resolveDeliveryBranch(projectRoot: string, runGit?: GitRunner): DeliveryBranchResult;
+export interface DeliveryBranchPolicyField {
+    readonly name: string;
+    readonly current: string;
+    readonly default: string;
+    readonly source: string;
+}
+/** Inspector row for `task policy:show --field=deliveryBranch` (#3041). */
+export declare function inspectDeliveryBranch(_data: Record<string, unknown> | null, projectRoot?: string): DeliveryBranchPolicyField;
+//# sourceMappingURL=delivery-branch.d.ts.map

package/dist/policy/delivery-branch.js

@@ -0,0 +1,124 @@
+/**
+ * Typed plan.policy.deliveryBranch (#3041).
+ *
+ * Distinct from swarm/PR `baseBranch` (integration target for PRs / finalize
+ * sweep PRs). deliveryBranch is where shipped work must land for a delivered
+ * completion disposition.
+ */
+import { defaultGitRunner } from "../session/git.js";
+import { readPlanPolicy } from "./plan-extensions.js";
+import { loadProjectDefinition } from "./resolve.js";
+export const FIELD_DELIVERY_BRANCH = "plan.policy.deliveryBranch";
+export const FIELD_DELIVERY_BRANCH_CLI_ALIAS = "deliveryBranch";
+/** Framework fallback when neither policy nor git default can be resolved. */
+export const DEFAULT_DELIVERY_BRANCH_FALLBACK = "master";
+function defaultBranchCandidates(projectRoot, runGit) {
+    const sym = runGit(projectRoot, ["symbolic-ref", "refs/remotes/origin/HEAD", "--short"]);
+    if (sym.code === 0 && sym.stdout) {
+        const trimmed = sym.stdout.trim();
+        // origin/main → main
+        const parts = trimmed.split("/");
+        const name = (parts.slice(1).join("/") || parts[0] || "").trim();
+        if (name.length > 0) {
+            return [name];
+        }
+    }
+    const candidates = [];
+    for (const branch of ["main", "master"]) {
+        const check = runGit(projectRoot, [
+            "show-ref",
+            "--verify",
+            "--quiet",
+            `refs/remotes/origin/${branch}`,
+        ]);
+        if (check.code === 0) {
+            candidates.push(branch);
+        }
+    }
+    if (candidates.length === 0) {
+        for (const branch of ["main", "master"]) {
+            const local = runGit(projectRoot, [
+                "show-ref",
+                "--verify",
+                "--quiet",
+                `refs/heads/${branch}`,
+            ]);
+            if (local.code === 0) {
+                candidates.push(branch);
+            }
+        }
+    }
+    return candidates;
+}
+/**
+ * Resolve the project's delivery branch (#3041).
+ *
+ * Order: typed plan.policy.deliveryBranch → git remote default → local main/master → "master".
+ */
+export function resolveDeliveryBranch(projectRoot, runGit = defaultGitRunner) {
+    const [data, err] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        const gitDefault = defaultBranchCandidates(projectRoot, runGit)[0];
+        if (gitDefault !== undefined) {
+            return { branch: gitDefault, source: "git-default", error: err };
+        }
+        return {
+            branch: DEFAULT_DELIVERY_BRANCH_FALLBACK,
+            source: "default-fallback",
+            error: err,
+        };
+    }
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        const gitDefault = defaultBranchCandidates(projectRoot, runGit)[0];
+        return {
+            branch: gitDefault ?? DEFAULT_DELIVERY_BRANCH_FALLBACK,
+            source: gitDefault !== undefined ? "git-default" : "default-fallback",
+            error: "PROJECT-DEFINITION 'plan' is not an object",
+        };
+    }
+    const policyBlock = readPlanPolicy(plan);
+    if (typeof policyBlock === "object" &&
+        policyBlock !== null &&
+        !Array.isArray(policyBlock) &&
+        "deliveryBranch" in policyBlock) {
+        const raw = policyBlock.deliveryBranch;
+        if (typeof raw !== "string" || raw.trim().length === 0) {
+            const gitDefault = defaultBranchCandidates(projectRoot, runGit)[0];
+            return {
+                branch: gitDefault ?? DEFAULT_DELIVERY_BRANCH_FALLBACK,
+                source: "default-on-error",
+                error: `plan.policy.deliveryBranch must be a non-empty string; got ${typeof raw}`,
+            };
+        }
+        return { branch: raw.trim(), source: "typed", error: null };
+    }
+    const gitDefault = defaultBranchCandidates(projectRoot, runGit)[0];
+    if (gitDefault !== undefined) {
+        return { branch: gitDefault, source: "git-default", error: null };
+    }
+    return {
+        branch: DEFAULT_DELIVERY_BRANCH_FALLBACK,
+        source: "default-fallback",
+        error: null,
+    };
+}
+/** Inspector row for `task policy:show --field=deliveryBranch` (#3041). */
+export function inspectDeliveryBranch(_data, projectRoot) {
+    if (projectRoot === undefined || projectRoot.length === 0) {
+        return {
+            name: FIELD_DELIVERY_BRANCH,
+            current: DEFAULT_DELIVERY_BRANCH_FALLBACK,
+            default: DEFAULT_DELIVERY_BRANCH_FALLBACK,
+            source: "default",
+        };
+    }
+    const resolved = resolveDeliveryBranch(projectRoot);
+    return {
+        name: FIELD_DELIVERY_BRANCH,
+        current: resolved.branch,
+        default: DEFAULT_DELIVERY_BRANCH_FALLBACK,
+        source: resolved.source,
+    };
+}
+//# sourceMappingURL=delivery-branch.js.map

package/dist/policy/index.d.ts

@@ -2,6 +2,8 @@ export * from "./agents-md-advisory.js";
 export * from "./autonomy.js";
 export * from "./capacity.js";
 export * from "./decisions.js";
+export * from "./deft-directive-disable.js";
+export * from "./delivery-branch.js";
 export * from "./disclosure.js";
 export * from "./host-hooks.js";
 export * from "./hotfix-criteria.js";

package/dist/policy/index.js

@@ -1,3 +1,4 @@
+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_HOTFIX_CRITERIA, FIELD_HOTFIX_CRITERIA_CLI_ALIAS, inspectHotfixCriteria, } from "./hotfix-criteria.js";
 import { readPlanPolicy } from "./plan-extensions.js";
@@ -12,6 +13,8 @@ export * from "./agents-md-advisory.js";
 export * from "./autonomy.js";
 export * from "./capacity.js";
 export * from "./decisions.js";
+export * from "./deft-directive-disable.js";
+export * from "./delivery-branch.js";
 export * from "./disclosure.js";
 export * from "./host-hooks.js";
 export * from "./hotfix-criteria.js";
@@ -38,6 +41,7 @@ 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_SWARM_SUBAGENT_BACKEND = "plan.policy.swarmSubagentBackend";
+// deliveryBranch also exported from delivery-branch.js via export *
 export const DEFAULT_SESSION_RITUAL_STALENESS_HOURS = 4;
 export const DEFAULT_TRIAGE_SCOPE_VALUE = [
     { rule: "all-open" },
@@ -296,6 +300,15 @@ function inspectHotfixCriteriaField(data) {
         source: field.source,
     };
 }
+function inspectDeliveryBranchField(data, projectRoot) {
+    const field = inspectDeliveryBranch(data, projectRoot);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 const REGISTERED_POLICIES = [
     inspectAllowDirectCommits,
     inspectWipCap,
@@ -308,6 +321,7 @@ const REGISTERED_POLICIES = [
         emptyIsTyped: true,
     }),
     inspectSwarmSubagentBackend,
+    inspectDeliveryBranchField,
     inspectHostHooksField,
     inspectStalenessTicklerField,
     inspectRuntimeAuthorityField,
@@ -337,7 +351,9 @@ export function inspectOnePolicy(name, projectRoot) {
                             ? FIELD_REQUIRE_HUMAN_MERGE
                             : name === FIELD_HOTFIX_CRITERIA_CLI_ALIAS
                                 ? FIELD_HOTFIX_CRITERIA
-                                : name;
+                                : name === FIELD_DELIVERY_BRANCH_CLI_ALIAS
+                                    ? FIELD_DELIVERY_BRANCH
+                                    : name;
     for (const field of inspectAllPolicies(projectRoot)) {
         if (field.name === normalized)
             return field;

package/dist/policy/plan-extensions.d.ts

@@ -17,6 +17,14 @@
 export declare const PLAN_POLICY_KEY = "x-directive/policy";
 /** Namespaced directive scope-completion note key. */
 export declare const PLAN_COMPLETED_NOTE_KEY = "x-directive/completedNote";
+/**
+ * Namespaced onboarding decision-provenance block (#1694 / #1695).
+ *
+ * Holds facts that must NOT be smuggled through policy value fields (e.g.
+ * `plan.policy.wipCap` presence must not mean "operator decided a WIP cap").
+ * Out-of-band from `x-directive/policy` so value and decision stay orthogonal.
+ */
+export declare const PLAN_ONBOARDING_KEY = "x-directive/onboarding";
 /** Legacy bare policy key (pre-#1650); read-side fallback / write-side migration source. */
 export declare const LEGACY_PLAN_POLICY_KEY = "policy";
 /** Legacy bare completedNote key (pre-#1650); read-side fallback / write-side migration source. */
@@ -25,6 +33,8 @@ export declare const LEGACY_PLAN_COMPLETED_NOTE_KEY = "completedNote";
 export declare function readPlanPolicy(plan: unknown): unknown;
 /** Read the directive completedNote from a plan (namespaced first, bare fallback). */
 export declare function readPlanCompletedNote(plan: unknown): unknown;
+/** Read the namespaced onboarding decision-provenance block (#1694). */
+export declare function readPlanOnboarding(plan: unknown): unknown;
 /**
  * Rename a legacy bare `policy` key to the namespaced key in place when only
  * the bare key is present. No-op when the namespaced key already exists or no

package/dist/policy/plan-extensions.js

@@ -17,6 +17,14 @@
 export const PLAN_POLICY_KEY = "x-directive/policy";
 /** Namespaced directive scope-completion note key. */
 export const PLAN_COMPLETED_NOTE_KEY = "x-directive/completedNote";
+/**
+ * Namespaced onboarding decision-provenance block (#1694 / #1695).
+ *
+ * Holds facts that must NOT be smuggled through policy value fields (e.g.
+ * `plan.policy.wipCap` presence must not mean "operator decided a WIP cap").
+ * Out-of-band from `x-directive/policy` so value and decision stay orthogonal.
+ */
+export const PLAN_ONBOARDING_KEY = "x-directive/onboarding";
 /** Legacy bare policy key (pre-#1650); read-side fallback / write-side migration source. */
 export const LEGACY_PLAN_POLICY_KEY = "policy";
 /** Legacy bare completedNote key (pre-#1650); read-side fallback / write-side migration source. */
@@ -42,6 +50,14 @@ export function readPlanPolicy(plan) {
 export function readPlanCompletedNote(plan) {
     return readPlanExtension(plan, PLAN_COMPLETED_NOTE_KEY, LEGACY_PLAN_COMPLETED_NOTE_KEY);
 }
+/** Read the namespaced onboarding decision-provenance block (#1694). */
+export function readPlanOnboarding(plan) {
+    const planObj = asPlanObject(plan);
+    if (planObj === null) {
+        return undefined;
+    }
+    return planObj[PLAN_ONBOARDING_KEY];
+}
 /**
  * Rename a legacy bare `policy` key to the namespaced key in place when only
  * the bare key is present. No-op when the namespaced key already exists or no

package/dist/pr-closing-keywords/detect.d.ts

@@ -1,5 +1,18 @@
 import type { Hit } from "./types.js";
 export declare const CLOSING_KEYWORD_RE: RegExp;
 export declare function renderHit(hit: Hit): string;
+/** Layer 0 FP hits only (#737): keyword in negation / quotation / example / code-block / blockquote. */
 export declare function findHits(text: string, source: string): Hit[];
+/**
+ * Intent-mode hits (#3015 class D): every closing-keyword + `#N` match, regardless of
+ * surrounding prose. GitHub closes on token presence; conditional English is ignored.
+ * reason is the FP category when present, otherwise `intent`.
+ */
+export declare function findAllClosingKeywordHits(text: string, source: string): Hit[];
+/**
+ * Body trailer `deft-close-intent: full` is intentionally NOT an authorization path.
+ * Intent-mode allowlist is CLI `--allow-close N,M` only (#3015 / Greptile class-D gate).
+ * Markdown examples must never suppress real closing-keyword findings.
+ */
+export declare function hasFullCloseIntent(_text: string): boolean;
 //# sourceMappingURL=detect.d.ts.map

package/dist/pr-closing-keywords/detect.js

@@ -21,7 +21,8 @@ const EXAMPLE_MARKERS = [
     /\blike\b/i,
 ];
 const BLOCKQUOTE_RE = /^\s*>\s/m;
-const CODE_FENCE_RE = /^```/m;
+/** CommonMark fenced code opener/closer at line start: 3+ backticks or 3+ tildes. */
+const CODE_FENCE_LINE_RE = /^(?:`{3,}|~{3,})/;
 function findAllMatches(text, re) {
     const flags = re.flags.includes("g") ? re.flags : `${re.flags}g`;
     const pattern = new RegExp(re.source, flags);
@@ -41,10 +42,41 @@ function lineStartingAt(text, offset) {
     }
     return text.slice(lineStart, lineEnd);
 }
+/**
+ * CommonMark fence stack: open and close must use the same character, and the
+ * closer length must be >= opener length. Mixed ``` / ~~~ or shorter closers
+ * do not pop the open fence.
+ */
 function isInsideCodeFence(text, offset) {
-    const prefix = text.slice(0, offset);
-    const matches = prefix.match(CODE_FENCE_RE);
-    return matches !== null && matches.length % 2 === 1;
+    let openChar = null;
+    let openLen = 0;
+    let lineStart = 0;
+    while (lineStart < offset) {
+        let lineEnd = text.indexOf("\n", lineStart);
+        if (lineEnd === -1 || lineEnd > offset) {
+            lineEnd = Math.min(text.length, offset);
+        }
+        const line = text.slice(lineStart, lineEnd);
+        const m = CODE_FENCE_LINE_RE.exec(line);
+        if (m !== null) {
+            const fence = m[0] ?? "";
+            const ch = fence[0];
+            const len = fence.length;
+            if (openChar === null) {
+                openChar = ch;
+                openLen = len;
+            }
+            else if (ch === openChar && len >= openLen) {
+                openChar = null;
+                openLen = 0;
+            }
+        }
+        if (lineEnd >= offset) {
+            break;
+        }
+        lineStart = lineEnd + 1;
+    }
+    return openChar !== null;
 }
 function classifyHit(text, match) {
     const start = match.index ?? 0;
@@ -88,6 +120,12 @@ export function renderHit(hit) {
     return (`  [${hit.source}] ${hit.reason}: ` +
         `"...${hit.context}..." -> ${hit.keyword} #${hit.issueNumber}`);
 }
+function snippetAround(text, match) {
+    const snippetStart = Math.max(0, (match.index ?? 0) - 30);
+    const snippetEnd = Math.min(text.length, (match.index ?? 0) + match[0].length + 30);
+    return text.slice(snippetStart, snippetEnd).replace(/\n/g, " ");
+}
+/** Layer 0 FP hits only (#737): keyword in negation / quotation / example / code-block / blockquote. */
 export function findHits(text, source) {
     const hits = [];
     const re = new RegExp(CLOSING_KEYWORD_RE.source, CLOSING_KEYWORD_RE.flags);
@@ -95,14 +133,11 @@ export function findHits(text, source) {
     while (match !== null) {
         const category = classifyHit(text, match);
         if (category !== null) {
-            const snippetStart = Math.max(0, (match.index ?? 0) - 30);
-            const snippetEnd = Math.min(text.length, (match.index ?? 0) + match[0].length + 30);
-            const context = text.slice(snippetStart, snippetEnd).replace(/\n/g, " ");
             hits.push({
                 source,
                 keyword: match[1] ?? "",
                 issueNumber: Number(match[2]),
-                context,
+                context: snippetAround(text, match),
                 reason: category,
             });
         }
@@ -110,4 +145,34 @@ export function findHits(text, source) {
     }
     return hits;
 }
+/**
+ * Intent-mode hits (#3015 class D): every closing-keyword + `#N` match, regardless of
+ * surrounding prose. GitHub closes on token presence; conditional English is ignored.
+ * reason is the FP category when present, otherwise `intent`.
+ */
+export function findAllClosingKeywordHits(text, source) {
+    const hits = [];
+    const re = new RegExp(CLOSING_KEYWORD_RE.source, CLOSING_KEYWORD_RE.flags);
+    let match = re.exec(text);
+    while (match !== null) {
+        const category = classifyHit(text, match);
+        hits.push({
+            source,
+            keyword: match[1] ?? "",
+            issueNumber: Number(match[2]),
+            context: snippetAround(text, match),
+            reason: category ?? "intent",
+        });
+        match = re.exec(text);
+    }
+    return hits;
+}
+/**
+ * Body trailer `deft-close-intent: full` is intentionally NOT an authorization path.
+ * Intent-mode allowlist is CLI `--allow-close N,M` only (#3015 / Greptile class-D gate).
+ * Markdown examples must never suppress real closing-keyword findings.
+ */
+export function hasFullCloseIntent(_text) {
+    return false;
+}
 //# sourceMappingURL=detect.js.map

package/dist/pr-closing-keywords/index.d.ts

@@ -1,7 +1,7 @@
 export { EXIT_CONFIG_ERROR, EXIT_HITS_FOUND, EXIT_OK, GH_TIMEOUT_S, WINDOW_RADIUS, } from "./constants.js";
-export { findHits, renderHit } from "./detect.js";
+export { findAllClosingKeywordHits, findHits, hasFullCloseIntent, renderHit, } from "./detect.js";
 export { defaultRunGh, fetchPrBody, fetchPrCommitMessages } from "./gh.js";
 export { readCommitsFile, readTextFile } from "./io.js";
 export { cmdPrCheckClosingKeywords, parseAllowList, parseArgs, run } from "./main.js";
-export type { Hit, ParsedArgs, RunGhFn, RunGhResult } from "./types.js";
+export type { ClosingKeywordMode, Hit, ParsedArgs, RunGhFn, RunGhResult } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/pr-closing-keywords/index.js

@@ -1,5 +1,5 @@
 export { EXIT_CONFIG_ERROR, EXIT_HITS_FOUND, EXIT_OK, GH_TIMEOUT_S, WINDOW_RADIUS, } from "./constants.js";
-export { findHits, renderHit } from "./detect.js";
+export { findAllClosingKeywordHits, findHits, hasFullCloseIntent, renderHit, } from "./detect.js";
 export { defaultRunGh, fetchPrBody, fetchPrCommitMessages } from "./gh.js";
 export { readCommitsFile, readTextFile } from "./io.js";
 export { cmdPrCheckClosingKeywords, parseAllowList, parseArgs, run } from "./main.js";