@deftai/directive-core 0.64.0 → 0.66.0

package/dist/triage/scope/resolve.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { readPlanPolicy } from "../../policy/plan-extensions.js";
 import { DEFAULT_TRIAGE_SCOPE, PROJECT_DEFINITION_REL_PATH } from "./constants.js";
 export function projectDefinitionPath(projectRoot) {
     return join(resolve(projectRoot), PROJECT_DEFINITION_REL_PATH);
@@ -24,7 +25,7 @@ export function isDefaultApplied(data) {
     const plan = data.plan;
     if (typeof plan !== "object" || plan === null || Array.isArray(plan))
         return true;
-    const policy = plan.policy;
+    const policy = readPlanPolicy(plan);
     if (typeof policy !== "object" || policy === null || Array.isArray(policy))
         return true;
     const scope = policy.triageScope;
@@ -36,7 +37,7 @@ export function getRawScope(data) {
     const plan = data.plan;
     if (typeof plan !== "object" || plan === null || Array.isArray(plan))
         return undefined;
-    const policy = plan.policy;
+    const policy = readPlanPolicy(plan);
     if (typeof policy !== "object" || policy === null || Array.isArray(policy))
         return undefined;
     return policy.triageScope;
@@ -47,7 +48,7 @@ export function getRawIgnores(data) {
     const plan = data.plan;
     if (typeof plan !== "object" || plan === null || Array.isArray(plan))
         return [];
-    const policy = plan.policy;
+    const policy = readPlanPolicy(plan);
     if (typeof policy !== "object" || policy === null || Array.isArray(policy))
         return [];
     const raw = policy.triageScopeIgnores;
@@ -65,7 +66,7 @@ export function resolveScopeRules(projectRoot, projectDefinition) {
     if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
         return DEFAULT_TRIAGE_SCOPE.map((r) => ({ ...r }));
     }
-    const policy = plan.policy;
+    const policy = readPlanPolicy(plan);
     if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
         return DEFAULT_TRIAGE_SCOPE.map((r) => ({ ...r }));
     }
@@ -91,7 +92,7 @@ export function resolveScopeIgnores(projectRoot, projectDefinition) {
     const plan = data.plan;
     if (typeof plan !== "object" || plan === null || Array.isArray(plan))
         return out;
-    const policy = plan.policy;
+    const policy = readPlanPolicy(plan);
     if (typeof policy !== "object" || policy === null || Array.isArray(policy))
         return out;
     const raw = policy.triageScopeIgnores;

package/dist/triage/scope/validate.js

@@ -1,3 +1,4 @@
+import { readPlanPolicy } from "../../policy/plan-extensions.js";
 import { REFERENCED_BY_VBRIEF_SCOPES, SLICED_FROM_SCOPES, VALID_IGNORE_KEYS, VALID_IGNORE_RULES, VALID_RULE_TYPES, } from "./constants.js";
 import { parseDurationMs } from "./duration.js";
 import { validateMilestoneRule } from "./milestone.js";
@@ -238,9 +239,7 @@ function pointerForError(err, rawList) {
 }
 export function validateTriageScopeOnPlan(plan, filepath) {
     const out = [];
-    const policy = typeof plan === "object" && plan !== null && !Array.isArray(plan)
-        ? plan.policy
-        : undefined;
+    const policy = readPlanPolicy(plan);
     const rawScope = typeof policy === "object" && policy !== null && !Array.isArray(policy)
         ? policy.triageScope
         : undefined;
@@ -254,9 +253,7 @@ export function validateTriageScopeOnPlan(plan, filepath) {
 }
 export function validateTriageScopeIgnoresOnPlan(plan, filepath) {
     const out = [];
-    const policy = typeof plan === "object" && plan !== null && !Array.isArray(plan)
-        ? plan.policy
-        : undefined;
+    const policy = readPlanPolicy(plan);
     const raw = typeof policy === "object" && policy !== null && !Array.isArray(policy)
         ? policy.triageScopeIgnores
         : undefined;

package/dist/triage/scope-drift/add-ignore.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdtempSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
+import { migrateLegacyPolicyKey, PLAN_POLICY_KEY } from "../../policy/plan-extensions.js";
 const PROJECT_DEFINITION_REL_PATH = "vbrief/PROJECT-DEFINITION.vbrief.json";
 function projectDefinitionPath(projectRoot) {
     return join(resolve(projectRoot), PROJECT_DEFINITION_REL_PATH);
@@ -54,10 +55,11 @@ export function addIgnore(projectRoot, options) {
         throw new Error(`PROJECT-DEFINITION at ${path} has a non-object 'plan' key`);
     }
     const planRec = plan;
-    let policy = planRec.policy;
+    migrateLegacyPolicyKey(planRec);
+    let policy = planRec[PLAN_POLICY_KEY];
     if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
         policy = {};
-        planRec.policy = policy;
+        planRec[PLAN_POLICY_KEY] = policy;
     }
     const policyRec = policy;
     const raw = Array.isArray(policyRec.triageScopeIgnores)

package/dist/triage/scope-drift/scope-rules.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { readPlanPolicy } from "../../policy/plan-extensions.js";
 const PROJECT_DEFINITION_REL_PATH = "vbrief/PROJECT-DEFINITION.vbrief.json";
 const DEFAULT_TRIAGE_SCOPE = [{ rule: "all-open" }];
 function loadProjectDefinition(projectRoot) {
@@ -25,7 +26,7 @@ export function resolveScopeRules(projectRoot, projectDefinition) {
     if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
         return DEFAULT_TRIAGE_SCOPE.map((r) => ({ ...r }));
     }
-    const policy = plan.policy;
+    const policy = readPlanPolicy(plan);
     if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
         return DEFAULT_TRIAGE_SCOPE.map((r) => ({ ...r }));
     }
@@ -47,7 +48,7 @@ export function resolveScopeIgnores(projectRoot, projectDefinition) {
     const plan = data.plan;
     if (typeof plan !== "object" || plan === null || Array.isArray(plan))
         return out;
-    const policy = plan.policy;
+    const policy = readPlanPolicy(plan);
     if (typeof policy !== "object" || policy === null || Array.isArray(policy))
         return out;
     const raw = policy.triageScopeIgnores;

package/dist/triage/subscribe/index.js

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
-import { basename, join, resolve } from "node:path";
+import { basename, join } from "node:path";
+import { resolveEvalPath, resolveProjectDefinitionPath } from "../../layout/resolve.js";
+import { migrateLegacyPolicyKey, PLAN_POLICY_KEY } from "../../policy/plan-extensions.js";
 export const SUBSCRIPTION_HISTORY_REL_PATH = "vbrief/.eval/subscription-history.jsonl";
 export const SUBSCRIPTION_HISTORY_SCHEMA = "deft.triage.subscription-change.v1";
 export const PROJECT_DEFINITION_REL_PATH = "vbrief/PROJECT-DEFINITION.vbrief.json";
@@ -15,7 +17,7 @@ export class ProjectDefinitionIOError extends Error {
     }
 }
 function projectDefinitionPath(projectRoot) {
-    return join(resolve(projectRoot), PROJECT_DEFINITION_REL_PATH);
+    return resolveProjectDefinitionPath(projectRoot);
 }
 export function loadProjectDefinitionForMutation(projectRoot) {
     const path = projectDefinitionPath(projectRoot);
@@ -87,7 +89,7 @@ function resolveActor(actor) {
     }
 }
 export function recordSubscriptionChange(projectRoot, options) {
-    const historyPath = join(resolve(projectRoot), SUBSCRIPTION_HISTORY_REL_PATH);
+    const historyPath = resolveEvalPath(projectRoot, "subscription-history.jsonl");
     const record = {
         schema: SUBSCRIPTION_HISTORY_SCHEMA,
         change_id: randomUUID(),
@@ -249,15 +251,19 @@ function mutate(projectRoot, options) {
         throw new Error(`PROJECT-DEFINITION at ${path} has a non-object 'plan' key`);
     }
     const plan = data.plan;
-    if (typeof plan.policy !== "object" || plan.policy === null || Array.isArray(plan.policy)) {
-        if (plan.policy === undefined) {
-            plan.policy = {};
+    migrateLegacyPolicyKey(plan);
+    const existingPolicy = plan[PLAN_POLICY_KEY];
+    if (typeof existingPolicy !== "object" ||
+        existingPolicy === null ||
+        Array.isArray(existingPolicy)) {
+        if (existingPolicy === undefined) {
+            plan[PLAN_POLICY_KEY] = {};
         }
         else {
             throw new Error(`PROJECT-DEFINITION at ${path} has a non-object 'plan.policy' key`);
         }
     }
-    const policy = plan.policy;
+    const policy = plan[PLAN_POLICY_KEY];
     if (!Array.isArray(policy.triageScope)) {
         if (policy.triageScope === undefined) {
             policy.triageScope = [];
@@ -298,6 +304,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,5 +1,8 @@
+import { createHash } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
 import { join, resolve as pathResolve } from "node:path";
+import { hasArtifactSuffix, resolveEvalPath, resolveLifecycleFolder, resolveProjectDefinitionPath, } from "../../layout/resolve.js";
+import { readPlanPolicy } from "../../policy/plan-extensions.js";
 import { loadProjectDefinition, PROJECT_DEFINITION_REL_PATH } from "../../policy/resolve.js";
 import { countVbriefWip, DEFAULT_WIP_CAP, resolveWipCap } from "../../policy/wip.js";
 import { AUDIT_LOG_REL_PATH, latestDecisions, readAuditLog } from "../actions/candidates-log.js";
@@ -16,6 +19,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";
@@ -90,13 +95,13 @@ export function iterCachedIssues(cacheRoot) {
 // ---------------------------------------------------------------------------
 /** Count filesystem-truth in-flight vBRIEFs (#1270). */
 export function countFilesystemInFlight(projectRoot) {
-    const folder = join(pathResolve(projectRoot), "vbrief", FILESYSTEM_IN_FLIGHT_FOLDER);
+    const folder = resolveLifecycleFolder(projectRoot, FILESYSTEM_IN_FLIGHT_FOLDER);
     if (!existsSync(folder)) {
         return 0;
     }
     let total = 0;
     for (const entry of readdirSync(folder, { withFileTypes: true })) {
-        if (!entry.isFile() || !entry.name.endsWith(".vbrief.json")) {
+        if (!entry.isFile() || !hasArtifactSuffix(entry.name)) {
             continue;
         }
         try {
@@ -121,7 +126,7 @@ export function countFilesystemInFlight(projectRoot) {
 }
 /** True iff `plan.policy.triageScope` is a non-empty list of dict rules. */
 export function isTriageScopeExplicitlyConfigured(projectRoot) {
-    const path = join(pathResolve(projectRoot), PROJECT_DEFINITION_REL_PATH);
+    const path = resolveProjectDefinitionPath(projectRoot);
     if (!existsSync(path)) {
         return false;
     }
@@ -134,7 +139,7 @@ export function isTriageScopeExplicitlyConfigured(projectRoot) {
         if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
             return false;
         }
-        const policy = plan.policy;
+        const policy = readPlanPolicy(plan);
         if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
             return false;
         }
@@ -155,13 +160,36 @@ 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
 // ---------------------------------------------------------------------------
 export function computeSummary(projectRoot, options = {}) {
     const root = pathResolve(projectRoot);
     const resolvedCacheRoot = options.cacheRoot ?? join(root, CACHE_DIR_NAME);
-    const resolvedLogPath = options.auditLogPath ?? join(root, CANDIDATES_LOG_REL_PATH);
+    const resolvedLogPath = options.auditLogPath ?? resolveEvalPath(root, "candidates.jsonl");
     const cached = iterCachedIssues(resolvedCacheRoot);
     const repos = [...new Set(cached.map(([repo]) => repo))].sort();
     const wipCap = resolveWipCapInt(root);
@@ -191,6 +219,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 +350,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 +364,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/summary/reconcilable.js

@@ -1,5 +1,7 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { referenceTypeMatches } from "@deftai/directive-types";
+import { hasArtifactSuffix, resolveEvalPath, resolveLifecycleRoot } from "../../layout/resolve.js";
 import { AUDIT_LOG_REL_PATH, readAuditLog } from "../actions/candidates-log.js";
 /** Lifecycle folders scanned for reconcilable vBRIEFs (#1468). */
 export const BACKFILL_FOLDERS = ["proposed", "pending", "active"];
@@ -36,7 +38,7 @@ function extractIssueRef(data) {
             continue;
         }
         const obj = ref;
-        if (obj.type !== "x-vbrief/github-issue") {
+        if (!referenceTypeMatches(String(obj.type ?? ""), "github-issue")) {
             continue;
         }
         const [repo, number] = parseGithubIssueUri(obj.uri);
@@ -61,11 +63,11 @@ function auditKey(repo, issueNumber) {
  */
 export function countReconcilable(projectRoot, options = {}) {
     try {
-        const auditPath = options.auditLogPath ?? join(projectRoot, CANDIDATES_LOG_REL_PATH);
+        const auditPath = options.auditLogPath ?? resolveEvalPath(projectRoot, "candidates.jsonl");
         const existing = existingAuditRefs(auditPath);
         const defaultRepo = options.defaultRepo ?? null;
         const keys = new Set();
-        const vbriefRoot = join(projectRoot, "vbrief");
+        const vbriefRoot = resolveLifecycleRoot(projectRoot);
         for (const folderName of BACKFILL_FOLDERS) {
             const folder = join(vbriefRoot, folderName);
             if (!existsSync(folder)) {
@@ -73,7 +75,7 @@ export function countReconcilable(projectRoot, options = {}) {
             }
             const entries = readdirSync(folder, { withFileTypes: true });
             for (const entry of entries) {
-                if (!entry.isFile() || !entry.name.endsWith(".vbrief.json")) {
+                if (!entry.isFile() || !hasArtifactSuffix(entry.name)) {
                     continue;
                 }
                 const path = join(folder, entry.name);

package/dist/triage/summary/scope-drift.js

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { readPlanPolicy } from "../../policy/plan-extensions.js";
 import { loadProjectDefinition } from "../../policy/resolve.js";
 const DRIFT_MIN_ISSUES = 3;
 const CACHE_SOURCE = "github-issue";
@@ -88,7 +89,7 @@ function resolveScopeRules(projectRoot) {
     if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
         return [{ rule: "all-open" }];
     }
-    const policy = plan.policy;
+    const policy = readPlanPolicy(plan);
     if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
         return [{ rule: "all-open" }];
     }

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/prior-state.js

@@ -1,8 +1,10 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { CACHE_DIR_NAME, CACHE_SOURCE, CANDIDATES_RELPATH, DEFAULT_WIP_CAP, SUBSCRIPTION_PRESETS, WIP_LIFECYCLE_DIRS, } from "./constants.js";
+import { hasArtifactSuffix, resolveAuditPath, resolveEvalPath, resolveLifecycleRoot, resolveProjectDefinitionPath, } from "../../layout/resolve.js";
+import { readPlanPolicy } from "../../policy/plan-extensions.js";
+import { CACHE_DIR_NAME, CACHE_SOURCE, DEFAULT_WIP_CAP, SUBSCRIPTION_PRESETS, WIP_LIFECYCLE_DIRS, } from "./constants.js";
 function loadProjectDefinition(projectRoot) {
-    const path = join(resolve(projectRoot), "vbrief", "PROJECT-DEFINITION.vbrief.json");
+    const path = resolveProjectDefinitionPath(projectRoot);
     if (!existsSync(path))
         return null;
     try {
@@ -37,17 +39,17 @@ function countCacheEntries(projectRoot) {
     return count;
 }
 export function candidatesLogPath(projectRoot) {
-    return join(resolve(projectRoot), ...CANDIDATES_RELPATH);
+    return resolveEvalPath(projectRoot, "candidates.jsonl");
 }
 function countWip(projectRoot) {
     let total = 0;
-    const root = join(resolve(projectRoot), "vbrief");
+    const root = resolveLifecycleRoot(projectRoot);
     for (const sub of WIP_LIFECYCLE_DIRS) {
         const folder = join(root, sub);
         if (!existsSync(folder))
             continue;
         for (const child of readdirSync(folder, { withFileTypes: true })) {
-            if (child.isFile() && child.name.endsWith(".vbrief.json"))
+            if (child.isFile() && hasArtifactSuffix(child.name))
                 total += 1;
         }
     }
@@ -80,7 +82,7 @@ function summarizeScope(rules) {
     return [true, `custom (${rules.length} rule(s))`];
 }
 function countPendingDecisions(projectRoot) {
-    const logPath = join(resolve(projectRoot), "vbrief", ".audit", "pending-human-decisions.jsonl");
+    const logPath = resolveAuditPath(projectRoot, "pending-human-decisions.jsonl");
     if (!existsSync(logPath))
         return 0;
     let text;
@@ -121,9 +123,7 @@ export function pendingDecisionsNudgeLine(count, threshold = 3) {
 export function detectPriorState(projectRoot) {
     const data = loadProjectDefinition(projectRoot) ?? {};
     const plan = data.plan;
-    const policy = typeof plan === "object" && plan !== null && !Array.isArray(plan)
-        ? plan.policy
-        : null;
+    const policy = readPlanPolicy(plan);
     const rawScope = typeof policy === "object" && policy !== null && !Array.isArray(policy)
         ? policy.triageScope
         : null;

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