@deftai/directive-core 0.89.0 → 0.91.0

package/dist/lifecycle/stats.js

@@ -0,0 +1,286 @@
+/**
+ * Local xBRIEF lifecycle folder stats for weekly process rollups (#2995).
+ *
+ * Filesystem-only inventory of `xbrief/{proposed,pending,active,completed,cancelled}/`.
+ * No network calls.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { hasArtifactSuffix, LEGACY_ARTIFACT_DIR, MIGRATED_ARTIFACT_DIR, } from "../layout/resolve.js";
+import { parseDurationMs } from "../triage/scope/duration.js";
+/** Lifecycle folders scanned for stats. */
+export const STATS_LIFECYCLE_FOLDERS = [
+    "proposed",
+    "pending",
+    "active",
+    "completed",
+    "cancelled",
+];
+/** Count semantics for WWYSYDH / process forms (stable strings for --json). */
+export const LIFECYCLE_STATS_SEMANTICS = {
+    promoted: "xbriefs currently in pending/ whose event time falls inside the --since window " +
+        "(promoted and still pending; later-activated work is not double-counted here).",
+    activated: "xbriefs currently in active/ whose event time falls inside the --since window " +
+        "(activated and still active).",
+    completed: "xbriefs currently in completed/ with plan.status completed (or unset, treated as completed) " +
+        "whose event time falls inside the --since window.",
+    cancelled_or_failed: "xbriefs currently in cancelled/, or in completed/ with plan.status failed, " +
+        "whose event time falls inside the --since window.",
+    still_active: "snapshot count of all xbriefs currently in active/ (not filtered by --since).",
+    event_time: "event time = most recent of plan.metadata.completedAt, plan.updated, and xBRIEFInfo/vBRIEFInfo.updated; " +
+        "else file mtime. Window is [as_of - since, as_of] inclusive of as_of.",
+    note: "Counts are current-folder membership, not full transition history. A brief that was " +
+        "promoted then activated in the same week appears under activated (and still_active), not promoted.",
+};
+function parseIso(value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return null;
+    }
+    const text = value.trim().endsWith("Z") ? `${value.trim().slice(0, -1)}+00:00` : value.trim();
+    const parsed = new Date(text);
+    if (Number.isNaN(parsed.getTime())) {
+        return null;
+    }
+    return parsed;
+}
+function readJsonObject(path) {
+    try {
+        const raw = readFileSync(path, "utf8");
+        const data = JSON.parse(raw);
+        if (typeof data !== "object" || data === null || Array.isArray(data)) {
+            return null;
+        }
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+function planOf(data) {
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return null;
+    }
+    return plan;
+}
+function infoUpdated(data) {
+    for (const key of ["xBRIEFInfo", "vBRIEFInfo"]) {
+        const info = data[key];
+        if (typeof info === "object" && info !== null && !Array.isArray(info)) {
+            const stamp = parseIso(info.updated);
+            if (stamp !== null) {
+                return stamp;
+            }
+        }
+    }
+    return null;
+}
+function completedAt(plan) {
+    const metadata = plan.metadata;
+    if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) {
+        return null;
+    }
+    return parseIso(metadata.completedAt);
+}
+/**
+ * Event time for window membership: most recent of completedAt / plan.updated /
+ * info.updated, else mtime. Preferring max (not completedAt-first) so a later
+ * cancel/restore transition is not stuck on a stale completion stamp.
+ */
+function eventTimeFor(data, plan, path) {
+    const candidates = [];
+    const completed = completedAt(plan);
+    if (completed !== null) {
+        candidates.push(completed);
+    }
+    const planUpdated = parseIso(plan.updated);
+    if (planUpdated !== null) {
+        candidates.push(planUpdated);
+    }
+    const info = infoUpdated(data);
+    if (info !== null) {
+        candidates.push(info);
+    }
+    if (candidates.length > 0) {
+        return new Date(Math.max(...candidates.map((d) => d.getTime())));
+    }
+    try {
+        return new Date(statSync(path).mtimeMs);
+    }
+    catch {
+        return null;
+    }
+}
+/** Stats root: xbrief/ if present, else legacy vbrief/ (read-only inventory), else canonical xbrief path. */
+function resolveStatsLifecycleRoot(projectRoot) {
+    const migrated = join(projectRoot, MIGRATED_ARTIFACT_DIR);
+    if (existsSync(migrated)) {
+        try {
+            if (statSync(migrated).isDirectory()) {
+                return migrated;
+            }
+        }
+        catch {
+            // fall through
+        }
+    }
+    const legacy = join(projectRoot, LEGACY_ARTIFACT_DIR);
+    if (existsSync(legacy)) {
+        try {
+            if (statSync(legacy).isDirectory()) {
+                return legacy;
+            }
+        }
+        catch {
+            // fall through
+        }
+    }
+    return migrated;
+}
+function statusOf(plan, folder) {
+    const raw = plan.status;
+    if (typeof raw === "string" && raw.trim().length > 0) {
+        return raw.trim();
+    }
+    if (folder === "completed") {
+        return "completed";
+    }
+    if (folder === "cancelled") {
+        return "cancelled";
+    }
+    if (folder === "pending") {
+        return "pending";
+    }
+    if (folder === "active") {
+        return "running";
+    }
+    return "proposed";
+}
+function inWindow(eventTime, windowStart, asOf) {
+    if (eventTime === null) {
+        return false;
+    }
+    const t = eventTime.getTime();
+    return t >= windowStart.getTime() && t <= asOf.getTime();
+}
+function emptyFolderTotals() {
+    return { proposed: 0, pending: 0, active: 0, completed: 0, cancelled: 0 };
+}
+function scanArtifacts(lifecycleRoot) {
+    const out = [];
+    for (const folder of STATS_LIFECYCLE_FOLDERS) {
+        const dir = join(lifecycleRoot, folder);
+        if (!existsSync(dir)) {
+            continue;
+        }
+        let names;
+        try {
+            names = readdirSync(dir)
+                .filter((name) => hasArtifactSuffix(name))
+                .sort();
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            const path = join(dir, name);
+            const data = readJsonObject(path);
+            if (data === null) {
+                continue;
+            }
+            const plan = planOf(data);
+            if (plan === null) {
+                continue;
+            }
+            out.push({
+                folder,
+                status: statusOf(plan, folder),
+                eventTime: eventTimeFor(data, plan, path),
+            });
+        }
+    }
+    return out;
+}
+function utcIso(dt) {
+    return `${dt.toISOString().slice(0, 19)}Z`;
+}
+/**
+ * Collect lifecycle folder stats for a project root.
+ * Offline / filesystem only.
+ */
+export function collectLifecycleStats(options) {
+    const sinceRaw = (options.since ?? "7d").trim() || "7d";
+    const sinceMs = parseDurationMs(sinceRaw);
+    const asOf = options.now ?? new Date();
+    const windowStart = new Date(asOf.getTime() - sinceMs);
+    const projectRoot = resolve(options.projectRoot);
+    const lifecycleRoot = resolveStatsLifecycleRoot(projectRoot);
+    const folder_totals = emptyFolderTotals();
+    let promoted = 0;
+    let activated = 0;
+    let completed = 0;
+    let cancelled_or_failed = 0;
+    let still_active = 0;
+    const records = existsSync(lifecycleRoot) ? scanArtifacts(lifecycleRoot) : [];
+    for (const rec of records) {
+        folder_totals[rec.folder] += 1;
+        if (rec.folder === "active") {
+            still_active += 1;
+        }
+        const win = inWindow(rec.eventTime, windowStart, asOf);
+        if (!win) {
+            continue;
+        }
+        if (rec.folder === "pending") {
+            promoted += 1;
+        }
+        else if (rec.folder === "active") {
+            activated += 1;
+        }
+        else if (rec.folder === "cancelled") {
+            cancelled_or_failed += 1;
+        }
+        else if (rec.folder === "completed") {
+            if (rec.status === "failed") {
+                cancelled_or_failed += 1;
+            }
+            else if (rec.status === "completed") {
+                completed += 1;
+            }
+            // Inconsistent statuses under completed/ (e.g. stale "running") are
+            // counted in folder_totals only — not in window metrics.
+        }
+    }
+    return {
+        since: sinceRaw,
+        since_ms: sinceMs,
+        as_of: utcIso(asOf),
+        window_start: utcIso(windowStart),
+        project_root: projectRoot,
+        lifecycle_root: lifecycleRoot,
+        promoted,
+        activated,
+        completed,
+        cancelled_or_failed,
+        still_active,
+        folder_totals: { ...folder_totals },
+        semantics: LIFECYCLE_STATS_SEMANTICS,
+    };
+}
+/** Format human-readable lifecycle stats text. */
+export function formatLifecycleStatsText(stats) {
+    const lines = [
+        `lifecycle:stats (since ${stats.since}, as of ${stats.as_of})`,
+        `  window: ${stats.window_start} → ${stats.as_of}`,
+        `  promoted: ${stats.promoted}`,
+        `  activated: ${stats.activated}`,
+        `  completed: ${stats.completed}`,
+        `  cancelled_or_failed: ${stats.cancelled_or_failed}`,
+        `  still_active: ${stats.still_active}`,
+        `  folder_totals: proposed=${stats.folder_totals.proposed} pending=${stats.folder_totals.pending} active=${stats.folder_totals.active} completed=${stats.folder_totals.completed} cancelled=${stats.folder_totals.cancelled}`,
+    ];
+    return `${lines.join("\n")}\n`;
+}
+/** Re-export duration parse for CLI error messaging. */
+export { parseDurationMs };
+//# sourceMappingURL=stats.js.map

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";