@deftai/directive-core 0.79.3 → 0.80.0

package/dist/staleness-tickler/probe-directive.js

@@ -0,0 +1,106 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { locateManifest, parseInstallManifest } from "../doctor/manifest.js";
+import { evaluateReleaseAvailability, } from "../doctor/release-availability.js";
+const PUBLIC_NPM_REGISTRY = "https://registry.npmjs.org/";
+function defaultReadText(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function defaultNpmView() {
+    const result = spawnSync("npm", [
+        "view",
+        "@deftai/directive",
+        "version",
+        `--registry=${PUBLIC_NPM_REGISTRY}`,
+        "--ignore-scripts",
+    ], { encoding: "utf8", timeout: 5_000 });
+    const version = (result.stdout ?? "").trim().split(/\r?\n/)[0]?.trim() ?? "";
+    return { ok: result.status === 0 && version.length > 0, version };
+}
+/** Parse `X.Y.Z` or `vX.Y.Z` core semver (ignores pre-release suffix). */
+export function parseSemverCore(version) {
+    const trimmed = version.trim().replace(/^v/i, "");
+    const core = trimmed.split("-")[0] ?? "";
+    const parts = core.split(".");
+    if (parts.length !== 3) {
+        return null;
+    }
+    const major = Number(parts[0]);
+    const minor = Number(parts[1]);
+    const patch = Number(parts[2]);
+    if (!Number.isFinite(major) || !Number.isFinite(minor) || !Number.isFinite(patch)) {
+        return null;
+    }
+    return { major, minor, patch };
+}
+export function computeDirectiveDistance(installedVersion, latestVersion) {
+    const installed = parseSemverCore(installedVersion);
+    const latest = parseSemverCore(latestVersion);
+    if (installed === null || latest === null) {
+        return { majorBehind: false, minorDistance: 0, patchDistance: 0 };
+    }
+    if (latest.major > installed.major) {
+        return {
+            majorBehind: true,
+            minorDistance: 0,
+            patchDistance: 0,
+        };
+    }
+    if (latest.major < installed.major) {
+        return { majorBehind: false, minorDistance: 0, patchDistance: 0 };
+    }
+    return {
+        majorBehind: false,
+        minorDistance: Math.max(0, latest.minor - installed.minor),
+        patchDistance: Math.max(0, latest.patch - installed.patch),
+    };
+}
+/**
+ * Probe Directive payload staleness via the public npm registry (#1692 substrate).
+ * Skips network when `DEFT_NO_NETWORK=1`.
+ */
+export function probeDirectiveStaleness(projectRoot, options = {}) {
+    const env = options.env ?? process.env;
+    const disclosure = `[deft staleness] Checking ${PUBLIC_NPM_REGISTRY} for Directive release drift.`;
+    if (env.DEFT_NO_NETWORK === "1") {
+        return null;
+    }
+    const readText = options.readText ?? defaultReadText;
+    const isFile = options.isFile ?? existsSync;
+    const manifestPath = locateManifest(projectRoot, null, isFile);
+    const manifestText = manifestPath ? readText(manifestPath) : null;
+    if (manifestText === null) {
+        return null;
+    }
+    const manifest = parseInstallManifest(manifestText);
+    const installed = (manifest.tag ?? manifest.ref ?? "").trim();
+    const notApplicable = evaluateReleaseAvailability(installed, null);
+    if (notApplicable.status === "not-applicable") {
+        return null;
+    }
+    let npmResult;
+    try {
+        npmResult = (options.runNpmView ?? defaultNpmView)();
+    }
+    catch {
+        npmResult = { ok: false, version: "" };
+    }
+    const availability = evaluateReleaseAvailability(installed, npmResult.ok ? npmResult.version : null);
+    const stale = availability.status === "available";
+    let distance = { majorBehind: false, minorDistance: 0, patchDistance: 0 };
+    if (availability.status === "available" || availability.status === "current") {
+        distance = computeDirectiveDistance(availability.installedVersion, availability.latestVersion);
+    }
+    return {
+        availability,
+        ...distance,
+        stale,
+        registryDisclosure: disclosure,
+    };
+}
+//# sourceMappingURL=probe-directive.js.map

package/dist/staleness-tickler/probe-xbrief.d.ts

@@ -0,0 +1,12 @@
+import type { XbriefDrift, XbriefSchemaDistance } from "./types.js";
+export interface ProbeXbriefOptions {
+    readonly targetVersion?: string;
+    readonly readText?: (path: string) => string | null;
+    readonly isFile?: (path: string) => boolean;
+    readonly resolveDefinitionPath?: (projectRoot: string) => string;
+}
+/** Classify declared xBRIEF schema distance vs the installed framework schema. */
+export declare function classifyXbriefSchemaDistance(declaredVersion: string | null, targetVersion: string): XbriefSchemaDistance;
+/** Probe xBRIEF schema staleness from PROJECT-DEFINITION declared version. */
+export declare function probeXbriefStaleness(projectRoot: string, options?: ProbeXbriefOptions): XbriefDrift;
+//# sourceMappingURL=probe-xbrief.d.ts.map

package/dist/staleness-tickler/probe-xbrief.js

@@ -0,0 +1,103 @@
+import { existsSync, readFileSync } from "node:fs";
+import { VBRIEF_VERSION } from "@deftai/directive-types";
+import { resolveProjectDefinitionPath } from "../layout/resolve.js";
+import { readDeclaredArtifactVersion } from "../xbrief-migrate/transforms.js";
+function defaultReadText(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function parseSchemaParts(version) {
+    const trimmed = version.trim();
+    const parts = trimmed.split(".");
+    if (parts.length < 2) {
+        return null;
+    }
+    const major = Number(parts[0]);
+    const minor = Number(parts[1]);
+    if (!Number.isFinite(major) || !Number.isFinite(minor)) {
+        return null;
+    }
+    return { major, minor };
+}
+/** Classify declared xBRIEF schema distance vs the installed framework schema. */
+export function classifyXbriefSchemaDistance(declaredVersion, targetVersion) {
+    if (declaredVersion === null) {
+        return "behind-major";
+    }
+    const declared = parseSchemaParts(declaredVersion);
+    const target = parseSchemaParts(targetVersion);
+    if (declared === null || target === null) {
+        return "behind-major";
+    }
+    if (declared.major < target.major) {
+        return "behind-major";
+    }
+    if (declared.major === target.major) {
+        const minorGap = target.minor - declared.minor;
+        if (minorGap >= 2) {
+            return "behind-major";
+        }
+        if (minorGap >= 1) {
+            return "behind-minor";
+        }
+    }
+    return "current";
+}
+/** Probe xBRIEF schema staleness from PROJECT-DEFINITION declared version. */
+export function probeXbriefStaleness(projectRoot, options = {}) {
+    const targetVersion = options.targetVersion ?? VBRIEF_VERSION;
+    const readText = options.readText ?? defaultReadText;
+    const isFile = options.isFile ?? existsSync;
+    let definitionPath;
+    try {
+        definitionPath =
+            options.resolveDefinitionPath?.(projectRoot) ?? resolveProjectDefinitionPath(projectRoot);
+    }
+    catch {
+        return {
+            declaredVersion: null,
+            targetVersion,
+            distance: "behind-major",
+            stale: true,
+        };
+    }
+    if (!isFile(definitionPath)) {
+        return {
+            declaredVersion: null,
+            targetVersion,
+            distance: "behind-major",
+            stale: true,
+        };
+    }
+    const text = readText(definitionPath);
+    if (text === null) {
+        return {
+            declaredVersion: null,
+            targetVersion,
+            distance: "behind-major",
+            stale: true,
+        };
+    }
+    let declared = null;
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+            declared = readDeclaredArtifactVersion(parsed);
+        }
+    }
+    catch {
+        declared = null;
+    }
+    const distance = classifyXbriefSchemaDistance(declared, targetVersion);
+    return {
+        declaredVersion: declared,
+        targetVersion,
+        distance,
+        stale: distance !== "current",
+    };
+}
+//# sourceMappingURL=probe-xbrief.js.map

package/dist/staleness-tickler/run.d.ts

@@ -0,0 +1,31 @@
+import { type IdleGateOptions } from "./idle.js";
+import { type ProbeDirectiveOptions } from "./probe-directive.js";
+import { type ProbeXbriefOptions } from "./probe-xbrief.js";
+import type { StalenessProbeResult, StalenessTicklerRunResult } from "./types.js";
+export declare const DIRECTIVE_UPGRADE_COMMAND = "npm i -g @deftai/directive@latest";
+export declare const XBRIEF_MIGRATE_COMMAND = "deft migrate:xbrief";
+export interface StalenessTicklerOptions {
+    readonly now?: Date;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly idle?: IdleGateOptions;
+    readonly probeDirective?: ProbeDirectiveOptions;
+    readonly probeXbrief?: ProbeXbriefOptions;
+    readonly askConsent?: (prompt: string) => "yes" | "no" | "snooze" | "remind";
+    readonly isInteractive?: boolean;
+    readonly executeUpgrade?: boolean;
+    readonly runUpgrade?: () => {
+        ok: boolean;
+        message: string;
+    };
+    readonly runMigrate?: (projectRoot: string) => {
+        ok: boolean;
+        message: string;
+    };
+}
+export declare function probeStalenessDimensions(projectRoot: string, options?: StalenessTicklerOptions): StalenessProbeResult;
+/**
+ * Maybe run the staleness tickler at a safe idle point (#2488 + #2489).
+ * Best-effort and non-fatal — callers should wrap in try/catch.
+ */
+export declare function maybeRunStalenessTickler(projectRoot: string, options?: StalenessTicklerOptions): StalenessTicklerRunResult;
+//# sourceMappingURL=run.d.ts.map

package/dist/staleness-tickler/run.js

@@ -0,0 +1,227 @@
+import { spawnSync } from "node:child_process";
+import { loadProjectDefinition } from "../policy/resolve.js";
+import { loadStalenessTicklerPolicy } from "../policy/staleness-tickler.js";
+import { runXbriefMigration } from "../xbrief-migrate/migrate-project.js";
+import { holdTierOnUnverified, isSnoozeActive, mergeHeldXbriefDistance, resolveTier, scoreDrift, shouldPromptDespiteSnooze, snoozeWindowMs, } from "./escalation.js";
+import { isInteractiveSession, isSafeIdlePoint, shouldSkipTicklerEntirely, } from "./idle.js";
+import { probeDirectiveStaleness } from "./probe-directive.js";
+import { probeXbriefStaleness } from "./probe-xbrief.js";
+import { loadStalenessTicklerState, saveStalenessTicklerState } from "./state.js";
+export const DIRECTIVE_UPGRADE_COMMAND = "npm i -g @deftai/directive@latest";
+export const XBRIEF_MIGRATE_COMMAND = "deft migrate:xbrief";
+const TIER_TONE = {
+    quiet: "note",
+    notice: "recommend",
+    strong: "strongly recommend",
+    assert: "assert",
+};
+function defaultAskConsent(_prompt) {
+    return "snooze";
+}
+function defaultRunUpgrade() {
+    const result = spawnSync("npm", ["i", "-g", "@deftai/directive@latest"], {
+        encoding: "utf8",
+        timeout: 120_000,
+    });
+    if (result.status === 0) {
+        return { ok: true, message: "Directive upgrade completed." };
+    }
+    const stderr = (result.stderr ?? "").trim();
+    return {
+        ok: false,
+        message: stderr.length > 0 ? stderr : `npm exited with status ${result.status ?? "unknown"}`,
+    };
+}
+function defaultRunMigrate(projectRoot) {
+    const io = { writeOut: () => { }, writeErr: () => { } };
+    const outcome = runXbriefMigration({ projectRoot }, io);
+    if (outcome.kind === "migrated") {
+        return {
+            ok: true,
+            message: `xBRIEF migration completed (${outcome.files} files; backup ${outcome.backupDir}).`,
+        };
+    }
+    if (outcome.kind === "converged" || outcome.kind === "noop") {
+        return { ok: true, message: outcome.message };
+    }
+    return { ok: false, message: outcome.message };
+}
+export function probeStalenessDimensions(projectRoot, options = {}) {
+    const directiveProbe = probeDirectiveStaleness(projectRoot, {
+        env: options.env,
+        ...options.probeDirective,
+    });
+    const xbrief = probeXbriefStaleness(projectRoot, options.probeXbrief);
+    const directive = directiveProbe
+        ? {
+            availability: directiveProbe.availability,
+            majorBehind: directiveProbe.majorBehind,
+            minorDistance: directiveProbe.minorDistance,
+            patchDistance: directiveProbe.patchDistance,
+            stale: directiveProbe.stale,
+        }
+        : {
+            availability: {
+                status: "unverified",
+                installedVersion: "0.0.0",
+                latestVersion: null,
+                resolver: "npm-view",
+            },
+            majorBehind: false,
+            minorDistance: 0,
+            patchDistance: 0,
+            stale: false,
+        };
+    const anyStale = directive.stale || xbrief.stale;
+    return {
+        directive,
+        xbrief,
+        anyStale,
+        directiveRegistryDisclosure: directiveProbe?.registryDisclosure,
+    };
+}
+function formatDimensionLines(probe) {
+    const lines = [];
+    if (probe.directive.stale && probe.directive.availability.status === "available") {
+        lines.push(`[deft staleness] Directive payload behind: installed v${probe.directive.availability.installedVersion}, ` +
+            `latest v${probe.directive.availability.latestVersion}. Run \`${DIRECTIVE_UPGRADE_COMMAND}\`.`);
+    }
+    if (probe.xbrief.stale) {
+        lines.push(`[deft staleness] xBRIEF schema ${probe.xbrief.distance}: declared ${probe.xbrief.declaredVersion ?? "unknown"}, ` +
+            `framework ${probe.xbrief.targetVersion}. Run \`${XBRIEF_MIGRATE_COMMAND}\`.`);
+    }
+    return lines;
+}
+function buildPromptLine(tier, probe) {
+    const tone = TIER_TONE[tier];
+    const actions = [];
+    if (probe.directive.stale) {
+        actions.push("upgrade Directive");
+    }
+    if (probe.xbrief.stale) {
+        actions.push("migrate xBRIEF");
+    }
+    const actionText = actions.join(" and ");
+    if (tier === "assert") {
+        return (`[deft staleness:${tone}] Version drift is compounding (${actionText}). ` +
+            "Plain snooze is unavailable — choose yes, opt-out via plan.policy.stalenessTickler.optOut, " +
+            "or remind after next release.");
+    }
+    return `[deft staleness:${tone}] ${actionText} now? [y/n/s]`;
+}
+function nextStateAfterPrompt(previous, tier, score, now, choice, policy, probe) {
+    const deferralCount = choice === "snooze" || choice === "no" || choice === "headless-advisory"
+        ? (previous.deferralCount ?? 0) + 1
+        : (previous.deferralCount ?? 0);
+    const windowMs = choice === "remind" ? policy.snooze.quietMs : snoozeWindowMs(tier, deferralCount, policy);
+    const snoozedUntil = new Date(now.getTime() + windowMs).toISOString();
+    return {
+        firstDetectedAt: previous.firstDetectedAt ?? now.toISOString(),
+        lastTier: tier,
+        lastScore: score,
+        lastPromptAt: now.toISOString(),
+        deferralCount,
+        snoozedUntil,
+        heldDirectiveLatest: probe.directive.availability.status === "available" ||
+            probe.directive.availability.status === "current"
+            ? probe.directive.availability.latestVersion
+            : (previous.heldDirectiveLatest ?? null),
+        heldXbriefDistance: mergeHeldXbriefDistance(probe.xbrief.distance, previous.heldXbriefDistance),
+        remindAfterNextRelease: choice === "remind" ? true : previous.remindAfterNextRelease,
+    };
+}
+/**
+ * Maybe run the staleness tickler at a safe idle point (#2488 + #2489).
+ * Best-effort and non-fatal — callers should wrap in try/catch.
+ */
+export function maybeRunStalenessTickler(projectRoot, options = {}) {
+    const env = options.env ?? process.env;
+    if (shouldSkipTicklerEntirely(env)) {
+        return { lines: [], prompted: false, skippedReason: "ritual-skip" };
+    }
+    const [data] = loadProjectDefinition(projectRoot);
+    const policy = loadStalenessTicklerPolicy(data);
+    const idle = isSafeIdlePoint(projectRoot, policy, { env, ...options.idle });
+    if (!idle.ok) {
+        return { lines: [], prompted: false, skippedReason: idle.reason };
+    }
+    const now = options.now ?? new Date();
+    const state = loadStalenessTicklerState(projectRoot);
+    const probe = probeStalenessDimensions(projectRoot, options);
+    if (!probe.anyStale) {
+        if (state.firstDetectedAt !== undefined ||
+            state.lastTier !== undefined ||
+            state.snoozedUntil !== undefined) {
+            saveStalenessTicklerState(projectRoot, {});
+        }
+        return { lines: [], prompted: false, skippedReason: "current" };
+    }
+    const directiveUnverified = probe.directive.availability.status === "unverified";
+    const xbriefDistance = directiveUnverified && state.heldXbriefDistance !== undefined
+        ? mergeHeldXbriefDistance(probe.xbrief.distance, state.heldXbriefDistance)
+        : probe.xbrief.distance;
+    const ageMs = state.firstDetectedAt !== undefined
+        ? Math.max(0, now.getTime() - Date.parse(state.firstDetectedAt))
+        : 0;
+    const inputs = {
+        directive: probe.directive,
+        xbrief: {
+            ...probe.xbrief,
+            distance: xbriefDistance,
+            stale: xbriefDistance !== "current",
+        },
+        ageMs,
+        deferralCount: state.deferralCount ?? 0,
+    };
+    const computedScore = scoreDrift(inputs, policy);
+    const computedTier = resolveTier(inputs, policy);
+    const { score, tier } = holdTierOnUnverified(computedTier, computedScore, state, directiveUnverified);
+    if (isSnoozeActive(state, now) && !shouldPromptDespiteSnooze(tier, state)) {
+        return { lines: [], prompted: false, skippedReason: "snoozed" };
+    }
+    const lines = [];
+    if (probe.directiveRegistryDisclosure) {
+        lines.push(probe.directiveRegistryDisclosure);
+    }
+    lines.push(...formatDimensionLines(probe));
+    lines.push(buildPromptLine(tier, probe));
+    const interactive = options.isInteractive ?? isInteractiveSession(env);
+    let choice;
+    if (!interactive) {
+        lines.push("[deft staleness] Non-interactive session — recommendation recorded; " +
+            "decline with plan.policy.stalenessTickler.optOut or wait for snooze window.");
+        choice = "headless-advisory";
+    }
+    else {
+        const ask = options.askConsent ?? defaultAskConsent;
+        const response = ask(lines.join("\n"));
+        if (tier === "assert" && response === "snooze") {
+            choice = "remind";
+            lines.push("[deft staleness] Assert tier: treating snooze as remind-after-next-release.");
+        }
+        else {
+            choice = response;
+        }
+    }
+    if (choice === "yes") {
+        const runUpgrade = options.runUpgrade ?? defaultRunUpgrade;
+        const runMigrate = options.runMigrate ?? defaultRunMigrate;
+        if (probe.directive.stale) {
+            lines.push(`[deft staleness] Running \`${DIRECTIVE_UPGRADE_COMMAND}\`…`);
+            const upgrade = runUpgrade();
+            lines.push(upgrade.ok
+                ? `[deft staleness] ${upgrade.message}`
+                : `[deft staleness] Upgrade failed (non-fatal): ${upgrade.message}`);
+        }
+        if (probe.xbrief.stale) {
+            lines.push(`[deft staleness] Running xBRIEF migration…`);
+            const migrate = runMigrate(projectRoot);
+            lines.push(migrate.ok
+                ? `[deft staleness] ${migrate.message}`
+                : `[deft staleness] Migration failed (non-fatal): ${migrate.message}`);
+        }
+    }
+    saveStalenessTicklerState(projectRoot, nextStateAfterPrompt(state, tier, score, now, choice, policy, probe));
+    return { lines, prompted: true };
+}
+//# sourceMappingURL=run.js.map

package/dist/staleness-tickler/state.d.ts

@@ -0,0 +1,10 @@
+import type { StalenessTicklerState } from "./types.js";
+export declare const STATE_RELATIVE_PATH: string;
+export interface StateIo {
+    readonly readText?: (path: string) => string | null;
+    readonly writeText?: (path: string, content: string) => void;
+}
+export declare function parseStalenessTicklerState(text: string | null): StalenessTicklerState;
+export declare function loadStalenessTicklerState(projectRoot: string, io?: StateIo): StalenessTicklerState;
+export declare function saveStalenessTicklerState(projectRoot: string, state: StalenessTicklerState, io?: StateIo): void;
+//# sourceMappingURL=state.d.ts.map

package/dist/staleness-tickler/state.js

@@ -0,0 +1,46 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+export const STATE_RELATIVE_PATH = join("xbrief", ".triage-cache", "staleness-tickler-state.json");
+function defaultReadText(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function defaultWriteText(path, content) {
+    mkdirSync(dirname(path), { recursive: true });
+    const temporary = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporary, content, "utf8");
+    renameSync(temporary, path);
+}
+export function parseStalenessTicklerState(text) {
+    if (text === null) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // stale state must never block operator work
+    }
+    return {};
+}
+export function loadStalenessTicklerState(projectRoot, io = {}) {
+    const path = join(projectRoot, STATE_RELATIVE_PATH);
+    return parseStalenessTicklerState((io.readText ?? defaultReadText)(path));
+}
+export function saveStalenessTicklerState(projectRoot, state, io = {}) {
+    const path = join(projectRoot, STATE_RELATIVE_PATH);
+    try {
+        (io.writeText ?? defaultWriteText)(path, `${JSON.stringify(state, null, 2)}\n`);
+    }
+    catch {
+        // persistence is best-effort
+    }
+}
+//# sourceMappingURL=state.js.map

package/dist/staleness-tickler/types.d.ts

@@ -0,0 +1,85 @@
+import type { ReleaseAvailabilityResult } from "../doctor/release-availability.js";
+/** Escalation tiers for the staleness tickler (#2489). */
+export declare const STALENESS_TICKLER_TIERS: readonly ["quiet", "notice", "strong", "assert"];
+export type StalenessTicklerTier = (typeof STALENESS_TICKLER_TIERS)[number];
+/** xBRIEF schema distance relative to the installed framework schema. */
+export declare const XBRIEF_SCHEMA_DISTANCES: readonly ["current", "behind-minor", "behind-major"];
+export type XbriefSchemaDistance = (typeof XBRIEF_SCHEMA_DISTANCES)[number];
+export interface ParsedSemverCore {
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+}
+export interface DirectiveDrift {
+    readonly availability: ReleaseAvailabilityResult;
+    readonly majorBehind: boolean;
+    readonly minorDistance: number;
+    readonly patchDistance: number;
+    readonly stale: boolean;
+}
+export interface XbriefDrift {
+    readonly declaredVersion: string | null;
+    readonly targetVersion: string;
+    readonly distance: XbriefSchemaDistance;
+    readonly stale: boolean;
+}
+export interface DriftInputs {
+    readonly directive: DirectiveDrift;
+    readonly xbrief: XbriefDrift;
+    readonly ageMs: number;
+    readonly deferralCount: number;
+}
+export interface DriftScoreResult {
+    readonly score: number;
+    readonly tier: StalenessTicklerTier;
+}
+export interface StalenessTicklerState {
+    readonly firstDetectedAt?: string;
+    readonly lastTier?: StalenessTicklerTier;
+    readonly lastScore?: number;
+    readonly lastPromptAt?: string;
+    readonly deferralCount?: number;
+    readonly snoozedUntil?: string;
+    readonly heldDirectiveLatest?: string | null;
+    readonly heldXbriefDistance?: XbriefSchemaDistance;
+    readonly remindAfterNextRelease?: boolean;
+}
+export interface StalenessTicklerWeights {
+    readonly directiveMajor: number;
+    readonly directiveMinor: number;
+    readonly directivePatch: number;
+    readonly schemaMajor: number;
+    readonly schemaMinor: number;
+    readonly agePerDay: number;
+    readonly deferral: number;
+}
+export interface StalenessTicklerTierThresholds {
+    readonly noticeMinorThreshold: number;
+    readonly strongAgeMs: number;
+    readonly assertDeferralCap: number;
+}
+export interface StalenessTicklerSnoozePolicy {
+    readonly quietMs: number;
+    readonly noticeMs: number;
+    readonly strongMs: number;
+    readonly maxWidenMultiplier: number;
+}
+export interface StalenessTicklerPolicy {
+    readonly enabled: boolean;
+    readonly optOut: boolean;
+    readonly weights: StalenessTicklerWeights;
+    readonly tiers: StalenessTicklerTierThresholds;
+    readonly snooze: StalenessTicklerSnoozePolicy;
+}
+export interface StalenessProbeResult {
+    readonly directive: DirectiveDrift;
+    readonly xbrief: XbriefDrift;
+    readonly anyStale: boolean;
+    readonly directiveRegistryDisclosure?: string;
+}
+export interface StalenessTicklerRunResult {
+    readonly lines: readonly string[];
+    readonly prompted: boolean;
+    readonly skippedReason?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/staleness-tickler/types.js

@@ -0,0 +1,5 @@
+/** Escalation tiers for the staleness tickler (#2489). */
+export const STALENESS_TICKLER_TIERS = ["quiet", "notice", "strong", "assert"];
+/** xBRIEF schema distance relative to the installed framework schema. */
+export const XBRIEF_SCHEMA_DISTANCES = ["current", "behind-minor", "behind-major"];
+//# sourceMappingURL=types.js.map

package/dist/triage/bootstrap/cache-module.d.ts

@@ -0,0 +1,25 @@
+/**
+ * TypeScript default cache module for triage:bootstrap (#2684).
+ *
+ * npm / packaged consumers never ship scripts/cache.py; bootstrap must use the
+ * same cacheFetchAll path as empty-cache auto-populate (#2575).
+ */
+import { type FetchAllReportImpl } from "../../cache/fetch.js";
+import type { CacheModule } from "./types.js";
+export type CacheFetchAllFn = (options: {
+    source: string;
+    repo: string;
+    batchSize?: number;
+    delayMs?: number;
+    state?: string;
+    limit?: number;
+    labels?: readonly string[];
+    author?: string | null;
+    cacheRoot?: string;
+    force?: boolean;
+}) => FetchAllReportImpl;
+/** Adapt TS cache reports to the bootstrap `FetchAllReport` shape. */
+export declare function bootstrapCacheModule(fetchAll?: CacheFetchAllFn): CacheModule;
+/** Default module for packaged and source checkouts — never gates on Python. */
+export declare function loadDefaultCacheModule(): CacheModule;
+//# sourceMappingURL=cache-module.d.ts.map