@deftai/directive-core 0.64.0 → 0.65.0

package/dist/content-contracts/standards/_helpers.js

@@ -63,6 +63,8 @@ const SKIP_DIRS = new Set([
     "dist",
     "tests",
     ".deft-cache",
+    // Swarm worktrees under .deft-scratch/ are not framework content (#1656).
+    ".deft-scratch",
     // node_modules holds third-party markdown (dependency READMEs) that is not
     // framework content; scanning it produced volatile, version-pinned cases that
     // broke CI when dependency versions drifted (#1993 follow-up).

package/dist/intake/issue-ingest.js

@@ -6,7 +6,7 @@ import { resolveProjectRoot } from "../scope/project-context.js";
 import { resolveProjectRepo } from "../slice/project-context.js";
 import { slugify, TODAY } from "../vbrief-build/build.js";
 import { EMITTED_VBRIEF_VERSION } from "../vbrief-build/constants.js";
-import { findAcHeading, parseCheckboxItems, parseListItems, sliceAcSection, stripCodeBlocks, } from "./markdown-scanners.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";
 export const INGEST_STATUSES = ["proposed", "pending", "active"];
 const STATUS_MAP = {
@@ -70,7 +70,7 @@ export function extractPlanItems(body) {
     if (body.length === 0) {
         return [];
     }
-    const text = stripCodeBlocks(body);
+    const text = stripFencedCodeBlocks(body);
     const checkboxItems = parseCheckboxItems(text);
     if (checkboxItems.length > 0) {
         return checkboxItems.map((item) => ({ title: item.title, status: item.status }));
@@ -313,11 +313,11 @@ export function fetchSingleIssue(repo, number, options = {}) {
     }
 }
 export function fetchIssue(repo, number, options = {}) {
-    const cached = fetchFromCache(repo, number, options);
-    if (cached !== null) {
-        return cached;
+    const live = fetchSingleIssue(repo, number, options);
+    if (live !== null) {
+        return live;
     }
-    return fetchSingleIssue(repo, number, options);
+    return fetchFromCache(repo, number, options);
 }
 export function ingestOne(issue, options) {
     const number = Number(issue.number);

package/dist/intake/markdown-scanners.d.ts

@@ -2,7 +2,9 @@
  * Linear-time markdown scanners for issue body parsing (#1784 / #1248).
  * Avoids nested/polynomial regex on issue bodies (ReDoS-safe).
  */
-/** Strip fenced and inline code spans before cross-ref / plan-item extraction. */
+/** Strip fenced code blocks only (preserves inline backtick spans). */
+export declare function stripFencedCodeBlocks(body: string): string;
+/** Strip fenced and inline code spans before cross-ref extraction. */
 export declare function stripCodeBlocks(body: string): string;
 export interface CheckboxItem {
     readonly title: string;

package/dist/intake/markdown-scanners.js

@@ -2,16 +2,23 @@
  * Linear-time markdown scanners for issue body parsing (#1784 / #1248).
  * Avoids nested/polynomial regex on issue bodies (ReDoS-safe).
  */
-/** Strip fenced and inline code spans before cross-ref / plan-item extraction. */
+/** Strip fenced code blocks only (preserves inline backtick spans). */
+export function stripFencedCodeBlocks(body) {
+    if (body.length === 0) {
+        return "";
+    }
+    return stripFencedCodeBlocksInner(body);
+}
+/** Strip fenced and inline code spans before cross-ref extraction. */
 export function stripCodeBlocks(body) {
     if (body.length === 0) {
         return "";
     }
-    let text = stripFencedCodeBlocks(body);
+    let text = stripFencedCodeBlocksInner(body);
     text = stripInlineCode(text);
     return text;
 }
-function stripFencedCodeBlocks(text) {
+function stripFencedCodeBlocksInner(text) {
     let out = "";
     let i = 0;
     while (i < text.length) {

package/dist/intake/reconcile-issues.js

@@ -2,6 +2,7 @@ import { execFileSync } from "node:child_process";
 import { mkdirSync, readdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { call } from "../scm/call.js";
+import { updateDecomposedChildBackReferences } from "../scope/decomposed-refs.js";
 import { resolveProjectRoot } from "../scope/project-context.js";
 import { resolveProjectRepo } from "../slice/project-context.js";
 export const LIFECYCLE_FOLDERS = [
@@ -643,6 +644,7 @@ export function applyLifecycleFixes(vbriefDir, report, projectRoot = null) {
             failures.push(`failed to move ${relPath} -> ${destFolder}/`);
             continue;
         }
+        updateDecomposedChildBackReferences(data, src, dst, vbriefDir);
         moved += 1;
     }
     return [moved, skipped, failures];

package/dist/preflight-cache/evaluate.js

@@ -14,6 +14,7 @@ import { execFileSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join, relative } from "node:path";
 import { probeCacheDrift } from "../cache/fetch.js";
+import { latestDecisionForIssue as auditLatestDecisionForIssue } from "../triage/actions/candidates-log.js";
 // ---------------------------------------------------------------------------
 // Public constants (mirror preflight_cache.py)
 // ---------------------------------------------------------------------------
@@ -258,43 +259,6 @@ function candidatesLogState(candidatesPath) {
         return "absent";
     }
 }
-function parseCandidates(candidatesPath) {
-    if (!existsSync(candidatesPath))
-        return [];
-    try {
-        const text = readFileSync(candidatesPath, "utf8");
-        const entries = [];
-        for (const line of text.split("\n")) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            try {
-                const data = JSON.parse(trimmed);
-                if (data !== null && typeof data === "object" && !Array.isArray(data)) {
-                    const d = data;
-                    entries.push({
-                        issue: Number(d.issue ?? d.issue_number ?? 0),
-                        repo: String(d.repo ?? ""),
-                        decision: String(d.decision ?? ""),
-                        ts: String(d.ts ?? d.timestamp ?? ""),
-                    });
-                }
-            }
-            catch {
-                /* skip malformed lines */
-            }
-        }
-        return entries;
-    }
-    catch {
-        return [];
-    }
-}
-function latestDecisionForIssue(candidates, repo, issueNumber) {
-    // Take all entries matching this issue (most recent last)
-    const matching = candidates.filter((c) => c.issue === issueNumber && c.repo === repo);
-    return matching[matching.length - 1] ?? null;
-}
 // ---------------------------------------------------------------------------
 // Main evaluate function
 // ---------------------------------------------------------------------------
@@ -541,9 +505,8 @@ function evaluateForIssue(repo, issueNumber, candidatesPath, cacheRoot, source,
             }
         }
     }
-    // Latest-decision check
-    const candidates = parseCandidates(candidatesPath);
-    const latest = latestDecisionForIssue(candidates, repo, issueNumber);
+    // Latest-decision check — shared audit-log reader (#1887 / candidates-log.ts)
+    const latest = auditLatestDecisionForIssue(issueNumber, repo, candidatesPath);
     if (latest === null) {
         return {
             code: 1,

package/dist/triage/queue/build-queue.js

@@ -1,5 +1,6 @@
 import { GROUP_ORDER } from "./constants.js";
 import { deriveGroup } from "./derive-group.js";
+import { hasActiveScopeIgnores, isCachedIssueScopeIgnored, } from "./scope-ignores-filter.js";
 import { compareSelectionKeys, matchedLabelFor, withinGroupSortKey } from "./selection.js";
 function resolveRank(issue, number, rankByNumber) {
     let candidate = rankByNumber.get(number);
@@ -71,6 +72,8 @@ export function buildQueue(issues, auditEntries, options) {
     const dropNetNew = Boolean(opts.finishBeforeStart && opts.wipAtCap);
     const includeBlocked = Boolean(opts.includeBlocked);
     const limit = opts.limit;
+    const scopeIgnores = opts.scopeIgnores;
+    const filterScopeIgnores = scopeIgnores !== undefined && hasActiveScopeIgnores(scopeIgnores);
     const decisions = latestDecisionsByIssue(auditEntries);
     const grouped = new Map();
     for (const group of GROUP_ORDER) {
@@ -81,6 +84,9 @@ export function buildQueue(issues, auditEntries, options) {
         if (typeof n !== "number") {
             continue;
         }
+        if (filterScopeIgnores && isCachedIssueScopeIgnored(issue, scopeIgnores)) {
+            continue;
+        }
         const isContinuation = resolveContinuation(issue, n, continuationNumbers);
         const isOrphan = orphanIssueNumbers.has(n);
         if (dropNetNew && !isContinuation && !isOrphan) {

package/dist/triage/queue/cache.js

@@ -1,6 +1,8 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { extractAuthor, extractMilestone } from "../scope-drift/cache-walker.js";
 import { CACHE_DIR_NAME, CACHE_SOURCE_GITHUB_ISSUE, DEFAULT_SLICES_LOG_REL_PATH, } from "./constants.js";
+import { hasActiveScopeIgnores, isRawIssueScopeIgnored, resolveScopeIgnores, } from "./scope-ignores-filter.js";
 import { blockedByIssueNumber, rankByIssueNumber } from "./scope-walk.js";
 function cachedState(issue) {
     if (issue === undefined) {
@@ -116,6 +118,8 @@ export function loadCachedIssues(repo, options) {
     }
     const rankMap = rankByIssueNumber(root);
     const blockedSet = blockedByIssueNumber(root);
+    const scopeIgnores = resolveScopeIgnores(root);
+    const filterScopeIgnores = hasActiveScopeIgnores(scopeIgnores);
     const issues = [];
     for (const entryName of readdirSync(base)) {
         if (!/^\d+$/.test(entryName)) {
@@ -150,11 +154,16 @@ export function loadCachedIssues(repo, options) {
         if (state !== "open" && !options.includeClosed) {
             continue;
         }
+        if (filterScopeIgnores && isRawIssueScopeIgnored(payload, scopeIgnores)) {
+            continue;
+        }
         issues.push({
             number: n,
             title: typeof payload.title === "string" ? payload.title : "",
             state,
             labels: parseLabels(payload.labels),
+            author: extractAuthor(payload),
+            milestone: extractMilestone(payload),
             updatedAt: typeof payload.updated_at === "string" ? payload.updated_at : "",
             createdAt: typeof payload.created_at === "string" ? payload.created_at : "",
             metadataRank: rankMap.get(n) ?? null,

package/dist/triage/queue/index.d.ts

@@ -6,6 +6,7 @@ export * from "./derive-group.js";
 export * from "./ranking-labels.js";
 export * from "./render.js";
 export * from "./repo.js";
+export * from "./scope-ignores-filter.js";
 export * from "./scope-walk.js";
 export * from "./selection.js";
 export * from "./types.js";

package/dist/triage/queue/index.js

@@ -6,6 +6,7 @@ export * from "./derive-group.js";
 export * from "./ranking-labels.js";
 export * from "./render.js";
 export * from "./repo.js";
+export * from "./scope-ignores-filter.js";
 export * from "./scope-walk.js";
 export * from "./selection.js";
 export * from "./types.js";

package/dist/triage/queue/scope-ignores-filter.d.ts

@@ -0,0 +1,12 @@
+import { resolveScopeIgnores, type ScopeIgnores } from "../scope-drift/scope-rules.js";
+export { resolveScopeIgnores, type ScopeIgnores };
+export declare function hasActiveScopeIgnores(ignores: ScopeIgnores): boolean;
+/** True when a cached raw.json payload matches any triageScopeIgnores entry. */
+export declare function isRawIssueScopeIgnored(raw: Record<string, unknown>, ignores: ScopeIgnores): boolean;
+/** True when a queue CachedIssue matches any triageScopeIgnores entry. */
+export declare function isCachedIssueScopeIgnored(issue: {
+    readonly labels: readonly string[];
+    readonly author?: string;
+    readonly milestone?: string;
+}, ignores: ScopeIgnores): boolean;
+//# sourceMappingURL=scope-ignores-filter.d.ts.map

package/dist/triage/queue/scope-ignores-filter.js

@@ -0,0 +1,50 @@
+import { extractAuthor, extractLabels, extractMilestone } from "../scope-drift/cache-walker.js";
+import { resolveScopeIgnores } from "../scope-drift/scope-rules.js";
+export { resolveScopeIgnores };
+export function hasActiveScopeIgnores(ignores) {
+    return ignores.labels.size > 0 || ignores.milestones.size > 0 || ignores.authors.size > 0;
+}
+/** True when a cached raw.json payload matches any triageScopeIgnores entry. */
+export function isRawIssueScopeIgnored(raw, ignores) {
+    if (ignores.authors.size > 0 && ignores.authors.has(extractAuthor(raw))) {
+        return true;
+    }
+    if (ignores.labels.size > 0) {
+        for (const label of extractLabels(raw)) {
+            if (ignores.labels.has(label)) {
+                return true;
+            }
+        }
+    }
+    if (ignores.milestones.size > 0) {
+        const milestone = extractMilestone(raw);
+        if (milestone && ignores.milestones.has(milestone)) {
+            return true;
+        }
+    }
+    return false;
+}
+/** True when a queue CachedIssue matches any triageScopeIgnores entry. */
+export function isCachedIssueScopeIgnored(issue, ignores) {
+    if (ignores.authors.size > 0 &&
+        issue.author !== undefined &&
+        issue.author.length > 0 &&
+        ignores.authors.has(issue.author)) {
+        return true;
+    }
+    if (ignores.labels.size > 0) {
+        for (const label of issue.labels) {
+            if (ignores.labels.has(label)) {
+                return true;
+            }
+        }
+    }
+    if (ignores.milestones.size > 0 &&
+        issue.milestone !== undefined &&
+        issue.milestone.length > 0 &&
+        ignores.milestones.has(issue.milestone)) {
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=scope-ignores-filter.js.map

package/dist/triage/queue/types.d.ts

@@ -1,4 +1,5 @@
 import type { QueueGroup } from "./constants.js";
+import type { ScopeIgnores } from "./scope-ignores-filter.js";
 /** One ranked row in buildQueue. */
 export interface QueueItem {
     readonly number: number;
@@ -25,6 +26,7 @@ export interface QueueBuildOptions {
     readonly blockedIssueNumbers?: ReadonlySet<number>;
     readonly includeBlocked?: boolean;
     readonly limit?: number | null;
+    readonly scopeIgnores?: ScopeIgnores;
 }
 /** Cached issue row produced by loadCachedIssues. */
 export interface CachedIssue {
@@ -32,6 +34,8 @@ export interface CachedIssue {
     readonly title: string;
     readonly state: string;
     readonly labels: readonly string[];
+    readonly author?: string;
+    readonly milestone?: string;
     readonly updatedAt: string;
     readonly createdAt: string;
     readonly metadataRank: number | null;

package/dist/triage/subscribe/index.js

@@ -298,6 +298,6 @@ export function subscribe(projectRoot, options = {}) {
 export function unsubscribe(projectRoot, options = {}) {
     return mutate(projectRoot, { op: "unsubscribe", ...options });
 }
-export const RECONCILE_HINT = "  Reconciliation: run `task triage:bootstrap -- --resume` to " +
+export const RECONCILE_HINT = "  Reconciliation: run `task triage:bootstrap` to " +
     "backfill / mark out-of-scope cached entries.";
 //# sourceMappingURL=index.js.map

package/dist/triage/summary/index.d.ts

@@ -8,6 +8,8 @@ export declare const CANDIDATES_LOG_REL_PATH = "vbrief/.eval/candidates.jsonl";
 export { latestDecisions, readAuditLog } from "../actions/candidates-log.js";
 export declare const SUMMARY_HISTORY_REL_PATH = "vbrief/.eval/summary-history.jsonl";
 export declare const SUMMARY_HISTORY_SCHEMA = "deft.triage.summary.v1";
+/** D2 repeat-suppression window for session-start triage one-liner (#1122 / #1279). */
+export declare const D2_SUPPRESSION_WINDOW_HOURS = 4;
 export declare const EMPTY_CACHE_LINE = "[triage] cache empty -- run task triage:bootstrap";
 export declare const WIP_LIFECYCLE_DIRS: readonly ["pending", "active"];
 export declare const FILESYSTEM_IN_FLIGHT_FOLDER = "active";
@@ -45,6 +47,10 @@ export declare function countFilesystemInFlight(projectRoot: string): number;
 export declare function isTriageScopeExplicitlyConfigured(projectRoot: string): boolean;
 /** Read `plan.policy.wipCap`; always returns an integer cap. */
 export declare function resolveWipCapInt(projectRoot: string): number;
+/** Read `raw.json` state for a cached github-issue entry; defaults to open when absent. */
+export declare function readCachedIssueState(cacheRoot: string, repo: string, issueNumber: number): string;
+/** True when a cached issue should participate in summary classification counts. */
+export declare function isCachedIssueOpen(cacheRoot: string, repo: string, issueNumber: number): boolean;
 export declare function computeSummary(projectRoot: string, options?: ComputeSummaryOptions): SummaryResult;
 export declare function formatOneLiner(result: SummaryResult, options?: {
     maxChars?: number;
@@ -58,6 +64,33 @@ export declare function summaryResultToRecord(result: SummaryResult, options: {
     emittedAt: string;
     line: string;
 }): Record<string, unknown>;
+/** Structured fields that drive operator-visible triage summary output (#1279). */
+export type SuppressionKeyFields = {
+    readonly cache_empty: boolean;
+    readonly untriaged: number;
+    readonly stale_defer: number;
+    readonly in_flight: number;
+    readonly in_flight_filesystem: number;
+    readonly in_flight_cache_scoped: number;
+    readonly triage_scope_configured: boolean;
+    readonly wip_count: number;
+    readonly wip_cap: number;
+    readonly repos: readonly string[];
+    readonly scope_drift: number;
+    readonly reconcilable: number;
+};
+export declare function suppressionKeyFieldsFromResult(result: SummaryResult): SuppressionKeyFields;
+/** Extract D2 suppression key fields from a summary-history JSONL record. */
+export declare function suppressionKeyFieldsFromRecord(record: Record<string, unknown>): SuppressionKeyFields | null;
+/** Canonical stable hash for D2 suppression comparison (#1279). */
+export declare function suppressionKey(result: SummaryResult): string;
+export declare function suppressionKeyFromRecord(record: Record<string, unknown>): string | null;
+/** Read the most recent JSONL record from summary-history.jsonl. */
+export declare function readLastHistoryRecord(historyPath: string): Record<string, unknown> | null;
+/** True when D2 should skip stdout emission (key unchanged within 4h). */
+export declare function shouldSuppressD2Emission(result: SummaryResult, historyPath: string, options?: {
+    now?: Date;
+}): boolean;
 /** Match Python `json.dumps(..., sort_keys=True, ensure_ascii=False)` spacing. */
 export declare function pythonStyleStringify(value: unknown): string;
 /** Append a single JSONL record to summary-history.jsonl. Never throws. */

package/dist/triage/summary/index.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
 import { join, resolve as pathResolve } from "node:path";
 import { loadProjectDefinition, PROJECT_DEFINITION_REL_PATH } from "../../policy/resolve.js";
@@ -16,6 +17,8 @@ export const CANDIDATES_LOG_REL_PATH = AUDIT_LOG_REL_PATH;
 export { latestDecisions, readAuditLog } from "../actions/candidates-log.js";
 export const SUMMARY_HISTORY_REL_PATH = "vbrief/.eval/summary-history.jsonl";
 export const SUMMARY_HISTORY_SCHEMA = "deft.triage.summary.v1";
+/** D2 repeat-suppression window for session-start triage one-liner (#1122 / #1279). */
+export const D2_SUPPRESSION_WINDOW_HOURS = 4;
 export const EMPTY_CACHE_LINE = "[triage] cache empty -- run task triage:bootstrap";
 export const WIP_LIFECYCLE_DIRS = ["pending", "active"];
 export const FILESYSTEM_IN_FLIGHT_FOLDER = "active";
@@ -155,6 +158,29 @@ export function resolveWipCapInt(projectRoot) {
 function decisionKey(repo, issueNumber) {
     return `${repo}\0${issueNumber}`;
 }
+/** Read `raw.json` state for a cached github-issue entry; defaults to open when absent. */
+export function readCachedIssueState(cacheRoot, repo, issueNumber) {
+    const [owner, name] = repo.split("/", 2);
+    const rawPath = join(cacheRoot, CACHE_SOURCE, owner ?? "", name ?? "", String(issueNumber), "raw.json");
+    if (!existsSync(rawPath)) {
+        return "open";
+    }
+    try {
+        const raw = JSON.parse(readFileSync(rawPath, { encoding: "utf8" }));
+        if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+            return "open";
+        }
+        const stateRaw = raw.state ?? "open";
+        return typeof stateRaw === "string" ? stateRaw.toLowerCase() : "open";
+    }
+    catch {
+        return "open";
+    }
+}
+/** True when a cached issue should participate in summary classification counts. */
+export function isCachedIssueOpen(cacheRoot, repo, issueNumber) {
+    return readCachedIssueState(cacheRoot, repo, issueNumber) !== "closed";
+}
 // ---------------------------------------------------------------------------
 // compute / format / persist
 // ---------------------------------------------------------------------------
@@ -191,6 +217,9 @@ export function computeSummary(projectRoot, options = {}) {
     let staleDefer = 0;
     const noDecisionKeys = [];
     for (const [repo, issueNumber] of cached) {
+        if (!isCachedIssueOpen(resolvedCacheRoot, repo, issueNumber)) {
+            continue;
+        }
         const decision = decisions.get(decisionKey(repo, issueNumber));
         if (decision === undefined || decision === "reset" || !TRIAGED_DECISIONS.has(decision)) {
             untriaged += 1;
@@ -319,6 +348,11 @@ export function summaryResultToRecord(result, options) {
         schema: SUMMARY_HISTORY_SCHEMA,
         emitted_at: options.emittedAt,
         line: options.line,
+        ...suppressionKeyFieldsFromResult(result),
+    };
+}
+export function suppressionKeyFieldsFromResult(result) {
+    return {
         cache_empty: result.cacheEmpty,
         untriaged: result.untriaged,
         stale_defer: result.staleDefer,
@@ -328,11 +362,149 @@ export function summaryResultToRecord(result, options) {
         triage_scope_configured: result.triageScopeConfigured,
         wip_count: result.wipCount,
         wip_cap: result.wipCap,
-        repos: [...result.repos],
+        repos: [...result.repos].sort(),
         scope_drift: result.scopeDrift,
         reconcilable: result.reconcilable,
     };
 }
+function readNumericField(record, key) {
+    const value = record[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readBooleanField(record, key) {
+    const value = record[key];
+    return typeof value === "boolean" ? value : null;
+}
+function readStringArrayField(record, key) {
+    const value = record[key];
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    if (!value.every((entry) => typeof entry === "string")) {
+        return null;
+    }
+    return [...value].sort();
+}
+/** Extract D2 suppression key fields from a summary-history JSONL record. */
+export function suppressionKeyFieldsFromRecord(record) {
+    const cacheEmpty = readBooleanField(record, "cache_empty");
+    const untriaged = readNumericField(record, "untriaged");
+    const staleDefer = readNumericField(record, "stale_defer");
+    const inFlight = readNumericField(record, "in_flight");
+    const inFlightFilesystem = readNumericField(record, "in_flight_filesystem");
+    const inFlightCacheScoped = readNumericField(record, "in_flight_cache_scoped");
+    const triageScopeConfigured = readBooleanField(record, "triage_scope_configured");
+    const wipCount = readNumericField(record, "wip_count");
+    const wipCap = readNumericField(record, "wip_cap");
+    const repos = readStringArrayField(record, "repos");
+    const scopeDrift = readNumericField(record, "scope_drift");
+    const reconcilable = readNumericField(record, "reconcilable");
+    if (cacheEmpty === null ||
+        untriaged === null ||
+        staleDefer === null ||
+        inFlight === null ||
+        inFlightFilesystem === null ||
+        inFlightCacheScoped === null ||
+        triageScopeConfigured === null ||
+        wipCount === null ||
+        wipCap === null ||
+        repos === null ||
+        scopeDrift === null ||
+        reconcilable === null) {
+        return null;
+    }
+    return {
+        cache_empty: cacheEmpty,
+        untriaged,
+        stale_defer: staleDefer,
+        in_flight: inFlight,
+        in_flight_filesystem: inFlightFilesystem,
+        in_flight_cache_scoped: inFlightCacheScoped,
+        triage_scope_configured: triageScopeConfigured,
+        wip_count: wipCount,
+        wip_cap: wipCap,
+        repos,
+        scope_drift: scopeDrift,
+        reconcilable,
+    };
+}
+/** Canonical stable hash for D2 suppression comparison (#1279). */
+export function suppressionKey(result) {
+    return createHash("sha256")
+        .update(pythonStyleStringify(suppressionKeyFieldsFromResult(result)))
+        .digest("hex");
+}
+export function suppressionKeyFromRecord(record) {
+    const fields = suppressionKeyFieldsFromRecord(record);
+    if (fields === null) {
+        return null;
+    }
+    return createHash("sha256").update(pythonStyleStringify(fields)).digest("hex");
+}
+function parseHistoryEmittedAt(record) {
+    const raw = record.emitted_at;
+    if (typeof raw !== "string" || raw.trim().length === 0) {
+        return null;
+    }
+    let candidate = raw.trim();
+    if (candidate.endsWith("Z")) {
+        candidate = `${candidate.slice(0, -1)}+00:00`;
+    }
+    const parsed = new Date(candidate);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+/** Read the most recent JSONL record from summary-history.jsonl. */
+export function readLastHistoryRecord(historyPath) {
+    if (!existsSync(historyPath)) {
+        return null;
+    }
+    let text;
+    try {
+        text = readFileSync(historyPath, { encoding: "utf8" });
+    }
+    catch {
+        return null;
+    }
+    const lines = text.split("\n").filter((line) => line.trim().length > 0);
+    if (lines.length === 0) {
+        return null;
+    }
+    const last = lines[lines.length - 1];
+    if (last === undefined) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(last);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+/** True when D2 should skip stdout emission (key unchanged within 4h). */
+export function shouldSuppressD2Emission(result, historyPath, options = {}) {
+    const prior = readLastHistoryRecord(historyPath);
+    if (prior === null) {
+        return false;
+    }
+    const emittedAt = parseHistoryEmittedAt(prior);
+    if (emittedAt === null) {
+        return false;
+    }
+    const now = options.now ?? new Date();
+    const ageMs = now.getTime() - emittedAt.getTime();
+    if (ageMs < 0 || ageMs >= D2_SUPPRESSION_WINDOW_HOURS * 3_600_000) {
+        return false;
+    }
+    const priorKey = suppressionKeyFromRecord(prior);
+    if (priorKey === null) {
+        return false;
+    }
+    return priorKey === suppressionKey(result);
+}
 function sortKeysDeep(value) {
     if (value === null || typeof value !== "object") {
         return value;

package/dist/triage/welcome/default-mode.d.ts

@@ -16,6 +16,7 @@ export interface DefaultModeOptions {
     readonly writeHistory?: boolean;
     readonly taskPrefix?: string | null;
     readonly selfHealFn?: (projectRoot: string) => void;
+    readonly now?: Date;
 }
 /** Non-interactive default mode (#1309). */
 export declare function runDefaultMode(projectRoot: string, options?: DefaultModeOptions): WelcomeOutcome;

package/dist/triage/welcome/default-mode.js

@@ -37,6 +37,7 @@ export function runDefaultMode(projectRoot, options = {}) {
     heal(projectRoot);
     emitOneliner(projectRoot, {
         writeHistory: options.writeHistory !== false,
+        now: options.now,
         output: out,
     });
     const state = detectPriorState(projectRoot);

package/dist/triage/welcome/summary.d.ts

@@ -19,5 +19,7 @@ export declare function appendHistory(historyPath: string, result: SummaryResult
 export declare function emitOneliner(projectRoot: string, options?: {
     writeHistory?: boolean;
     output?: (line: string) => void;
+    now?: Date;
+    applyD2Suppression?: boolean;
 }): string;
 //# sourceMappingURL=summary.d.ts.map

package/dist/triage/welcome/summary.js

@@ -3,7 +3,8 @@ import { join, resolve } from "node:path";
 import { countVbriefWip, DEFAULT_WIP_CAP, resolveWipCap } from "../../policy/wip.js";
 import { countReconcilable } from "../reconcile/reconcile.js";
 import { computeDrift } from "../scope-drift/compute.js";
-import { CACHE_DIR_NAME, CACHE_SOURCE, EMPTY_CACHE_LINE, MAX_LINE_CHARS, SUMMARY_HISTORY_REL_PATH, SUMMARY_HISTORY_SCHEMA, WIP_WARN_GLYPH, } from "./constants.js";
+import { SUMMARY_HISTORY_REL_PATH, shouldSuppressD2Emission } from "../summary/index.js";
+import { CACHE_DIR_NAME, CACHE_SOURCE, EMPTY_CACHE_LINE, MAX_LINE_CHARS, SUMMARY_HISTORY_SCHEMA, WIP_WARN_GLYPH, } from "./constants.js";
 const CANDIDATES_LOG_REL_PATH = "vbrief/.eval/candidates.jsonl";
 const FILESYSTEM_IN_FLIGHT_STATUS = "running";
 const TRIAGED_DECISIONS = new Set([
@@ -291,12 +292,17 @@ export function appendHistory(historyPath, result, line) {
 export function emitOneliner(projectRoot, options = {}) {
     const result = computeSummary(projectRoot);
     const line = formatSummary(result);
+    const historyPath = join(resolve(projectRoot), SUMMARY_HISTORY_REL_PATH);
+    const applySuppression = options.applyD2Suppression !== false;
+    if (applySuppression && shouldSuppressD2Emission(result, historyPath, { now: options.now })) {
+        return line;
+    }
     const out = options.output ?? ((l) => process.stdout.write(`${l}\n`));
     for (const physicalLine of line.split("\n")) {
         out(physicalLine);
     }
     if (options.writeHistory !== false) {
-        appendHistory(join(resolve(projectRoot), SUMMARY_HISTORY_REL_PATH), result, line);
+        appendHistory(historyPath, result, line);
     }
     return line;
 }

package/dist/verify-source/contract-drift.d.ts

@@ -0,0 +1,29 @@
+/**
+ * contract-drift.ts — deterministic gate for the public contract layer (#1799).
+ *
+ * Ensures:
+ *   1. packages/types/schemas/vbrief-core-0.6.schema.json matches the canonical
+ *      content/vbrief/schemas/vbrief-core.schema.json byte-for-byte.
+ *   2. @deftai/directive-types Status enum matches the schema Status enum.
+ *   3. @deftai/directive-types VBRIEF_VERSION matches the schema version const.
+ *
+ * Exit codes: 0 clean / 1 drift / 2 config error.
+ */
+import { type GateExitCode } from "@deftai/directive-types";
+export declare const EXIT_OK = 0;
+export declare const EXIT_DRIFT = 1;
+export declare const EXIT_CONFIG_ERROR = 2;
+export declare const CANONICAL_SCHEMA_REL = "content/vbrief/schemas/vbrief-core.schema.json";
+export declare const PUBLISHED_SCHEMA_REL = "packages/types/schemas/vbrief-core-0.6.schema.json";
+export interface ContractDriftResult {
+    readonly code: GateExitCode;
+    readonly message: string;
+    readonly stream: "stdout" | "stderr";
+}
+export interface ContractDriftOptions {
+    readonly root: string;
+    readonly readText?: (path: string) => string;
+}
+/** Evaluate contract drift for the directive source tree. */
+export declare function evaluateContractDrift(projectRoot: string, options?: Partial<ContractDriftOptions>): ContractDriftResult;
+//# sourceMappingURL=contract-drift.d.ts.map

package/dist/verify-source/contract-drift.js

@@ -0,0 +1,152 @@
+/**
+ * contract-drift.ts — deterministic gate for the public contract layer (#1799).
+ *
+ * Ensures:
+ *   1. packages/types/schemas/vbrief-core-0.6.schema.json matches the canonical
+ *      content/vbrief/schemas/vbrief-core.schema.json byte-for-byte.
+ *   2. @deftai/directive-types Status enum matches the schema Status enum.
+ *   3. @deftai/directive-types VBRIEF_VERSION matches the schema version const.
+ *
+ * Exit codes: 0 clean / 1 drift / 2 config error.
+ */
+import { readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { VALID_STATUSES, VBRIEF_VERSION } from "@deftai/directive-types";
+export const EXIT_OK = 0;
+export const EXIT_DRIFT = 1;
+export const EXIT_CONFIG_ERROR = 2;
+export const CANONICAL_SCHEMA_REL = "content/vbrief/schemas/vbrief-core.schema.json";
+export const PUBLISHED_SCHEMA_REL = "packages/types/schemas/vbrief-core-0.6.schema.json";
+function defaultReadText(path) {
+    return readFileSync(path, "utf8");
+}
+function loadSchemaJson(text, label) {
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            throw new Error(`${label} is not a JSON object`);
+        }
+        return parsed;
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`${label} is not valid JSON: ${detail}`);
+    }
+}
+function schemaStatusEnum(schema) {
+    const defs = schema.$defs;
+    if (typeof defs !== "object" || defs === null || Array.isArray(defs)) {
+        throw new Error("schema missing $defs");
+    }
+    const status = defs.Status;
+    if (typeof status !== "object" || status === null || Array.isArray(status)) {
+        throw new Error("schema missing $defs.Status");
+    }
+    const enumValues = status.enum;
+    if (!Array.isArray(enumValues) || enumValues.some((v) => typeof v !== "string")) {
+        throw new Error("schema $defs.Status.enum must be a string array");
+    }
+    return [...enumValues];
+}
+function schemaVersionConst(schema) {
+    const defs = schema.$defs;
+    if (typeof defs !== "object" || defs === null || Array.isArray(defs)) {
+        throw new Error("schema missing $defs");
+    }
+    const info = defs.vBRIEFInfo;
+    if (typeof info !== "object" || info === null || Array.isArray(info)) {
+        throw new Error("schema missing $defs.vBRIEFInfo");
+    }
+    const properties = info.properties;
+    if (typeof properties !== "object" || properties === null || Array.isArray(properties)) {
+        throw new Error("schema missing $defs.vBRIEFInfo.properties");
+    }
+    const version = properties.version;
+    if (typeof version !== "object" || version === null || Array.isArray(version)) {
+        throw new Error("schema missing $defs.vBRIEFInfo.properties.version");
+    }
+    const constValue = version.const;
+    if (typeof constValue !== "string") {
+        throw new Error("schema $defs.vBRIEFInfo.properties.version.const must be a string");
+    }
+    return constValue;
+}
+function sortedStrings(values) {
+    return [...values].sort();
+}
+/** Evaluate contract drift for the directive source tree. */
+export function evaluateContractDrift(projectRoot, options = {}) {
+    const root = resolve(projectRoot);
+    const readText = options.readText ?? defaultReadText;
+    const canonicalPath = join(root, CANONICAL_SCHEMA_REL);
+    const publishedPath = join(root, PUBLISHED_SCHEMA_REL);
+    let canonicalText;
+    let publishedText;
+    try {
+        canonicalText = readText(canonicalPath);
+        publishedText = readText(publishedPath);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return {
+            code: EXIT_CONFIG_ERROR,
+            message: `contract-drift: config error — could not read schema files (${detail}). Run pnpm --prefix packages/types run prebuild.`,
+            stream: "stderr",
+        };
+    }
+    if (canonicalText !== publishedText) {
+        return {
+            code: EXIT_DRIFT,
+            message: `contract-drift: ${PUBLISHED_SCHEMA_REL} is out of sync with ${CANONICAL_SCHEMA_REL}. ` +
+                "Run: pnpm --prefix packages/types run prebuild",
+            stream: "stderr",
+        };
+    }
+    let schema;
+    try {
+        schema = loadSchemaJson(canonicalText, CANONICAL_SCHEMA_REL);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return {
+            code: EXIT_CONFIG_ERROR,
+            message: `contract-drift: config error — ${detail}`,
+            stream: "stderr",
+        };
+    }
+    try {
+        const schemaStatuses = sortedStrings(schemaStatusEnum(schema));
+        const typeStatuses = sortedStrings(VALID_STATUSES);
+        if (schemaStatuses.join("|") !== typeStatuses.join("|")) {
+            return {
+                code: EXIT_DRIFT,
+                message: "contract-drift: VALID_STATUSES in @deftai/directive-types diverges from " +
+                    `$defs.Status.enum in ${CANONICAL_SCHEMA_REL}.`,
+                stream: "stderr",
+            };
+        }
+        const schemaVersion = schemaVersionConst(schema);
+        if (schemaVersion !== VBRIEF_VERSION) {
+            return {
+                code: EXIT_DRIFT,
+                message: "contract-drift: VBRIEF_VERSION in @deftai/directive-types diverges from " +
+                    "schema vBRIEFInfo.version const.",
+                stream: "stderr",
+            };
+        }
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return {
+            code: EXIT_CONFIG_ERROR,
+            message: `contract-drift: config error — ${detail}`,
+            stream: "stderr",
+        };
+    }
+    return {
+        code: EXIT_OK,
+        message: "contract-drift: canonical schema, published copy, and TS contract constants are in sync.",
+        stream: "stdout",
+    };
+}
+//# sourceMappingURL=contract-drift.js.map

package/dist/verify-source/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./code-structure-validate.js";
 export * from "./content-manifest.js";
+export { CANONICAL_SCHEMA_REL, type ContractDriftOptions, type ContractDriftResult, evaluateContractDrift, PUBLISHED_SCHEMA_REL, } from "./contract-drift.js";
 export * from "./cursor-tier1.js";
 export * from "./python-call-scan.js";
 export * from "./rule-ownership-lint.js";

package/dist/verify-source/index.js

@@ -1,5 +1,6 @@
 export * from "./code-structure-validate.js";
 export * from "./content-manifest.js";
+export { CANONICAL_SCHEMA_REL, evaluateContractDrift, PUBLISHED_SCHEMA_REL, } from "./contract-drift.js";
 export * from "./cursor-tier1.js";
 export * from "./python-call-scan.js";
 export * from "./rule-ownership-lint.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.64.0",
+  "version": "0.65.0",
   "description": "TypeScript engine core for the Directive framework.",
   "type": "module",
   "main": "./dist/index.js",
@@ -229,8 +229,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-content": "^0.64.0",
-    "@deftai/directive-types": "^0.64.0",
+    "@deftai/directive-content": "^0.65.0",
+    "@deftai/directive-types": "^0.65.0",
     "archiver": "^8.0.0"
   },
   "scripts": {