@deftai/directive-core 0.79.4 → 0.81.0

package/dist/scope/main.js

@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { maybeRunStalenessTickler } from "../staleness-tickler/run.js";
 import { reconcileUmbrellas, renderUmbrellasReport } from "../vbrief-reconcile/umbrellas.js";
 import { canonicalLogPath, readAll } from "./audit-log.js";
 import { TRANSITIONS } from "./constants.js";
@@ -110,6 +111,17 @@ export function lifecycleMain(argv) {
             catch {
                 /* best-effort drift warning + reconcile; lifecycle success remains authoritative */
             }
+            try {
+                const rootForTickler = resolveProjectRoot(projectRoot) ??
+                    dirname(dirname(dirname(completedPathForScopeMove(filePath))));
+                const tickler = maybeRunStalenessTickler(rootForTickler);
+                for (const line of tickler.lines) {
+                    process.stdout.write(`${line}\n`);
+                }
+            }
+            catch {
+                /* best-effort staleness tickler; lifecycle success remains authoritative */
+            }
         }
         return 0;
     }

package/dist/session/release-availability.d.ts

@@ -0,0 +1,21 @@
+export interface ReleaseAvailabilityProbeOptions {
+    readonly now?: Date;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly readText?: (path: string) => string | null;
+    readonly isFile?: (path: string) => boolean;
+    readonly runNpmView?: () => {
+        ok: boolean;
+        version: string;
+    };
+    readonly readState?: (path: string) => string | null;
+    readonly writeState?: (path: string, content: string) => void;
+}
+export interface ReleaseAvailabilityProbeResult {
+    readonly lines: readonly string[];
+}
+/**
+ * Probe the public npm registry separately from doctor. Doctor stays offline
+ * by default (#2182); mutable session start may emit this bounded advisory.
+ */
+export declare function probeSessionReleaseAvailability(projectRoot: string, options?: ReleaseAvailabilityProbeOptions): ReleaseAvailabilityProbeResult;
+//# sourceMappingURL=release-availability.d.ts.map

package/dist/session/release-availability.js

@@ -0,0 +1,109 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { locateManifest, parseInstallManifest } from "../doctor/manifest.js";
+import { runningInsideDeftRepo } from "../doctor/paths.js";
+import { evaluateReleaseAvailability } from "../doctor/release-availability.js";
+const THROTTLE_MS = 24 * 60 * 60 * 1000;
+const PUBLIC_NPM_REGISTRY = "https://registry.npmjs.org/";
+const STATE_RELATIVE_PATH = join("xbrief", ".triage-cache", "release-availability-state.json");
+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 };
+}
+function parseState(text) {
+    if (text === null)
+        return {};
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed !== null && typeof parsed === "object") {
+            return parsed;
+        }
+    }
+    catch {
+        // A stale advisory state is never allowed to block session start.
+    }
+    return {};
+}
+function isThrottled(state, latestVersion, now) {
+    if (state.latestVersion !== latestVersion || !state.notifiedAt)
+        return false;
+    const notifiedAt = Date.parse(state.notifiedAt);
+    return Number.isFinite(notifiedAt) && now.getTime() - notifiedAt < THROTTLE_MS;
+}
+function defaultWriteState(path, content) {
+    mkdirSync(dirname(path), { recursive: true });
+    const temporary = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporary, content, "utf8");
+    renameSync(temporary, path);
+}
+/**
+ * Probe the public npm registry separately from doctor. Doctor stays offline
+ * by default (#2182); mutable session start may emit this bounded advisory.
+ */
+export function probeSessionReleaseAvailability(projectRoot, options = {}) {
+    const env = options.env ?? process.env;
+    if (env.DEFT_NO_NETWORK === "1") {
+        return { lines: ["[deft release] skipped (DEFT_NO_NETWORK=1)."] };
+    }
+    if (runningInsideDeftRepo(projectRoot)) {
+        return { lines: [] };
+    }
+    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 { lines: [] };
+    const manifest = parseInstallManifest(manifestText);
+    const installed = (manifest.tag ?? manifest.ref ?? "").trim();
+    if (evaluateReleaseAvailability(installed, null).status === "not-applicable") {
+        return { lines: [] };
+    }
+    const lines = [
+        `[deft release] Checking ${PUBLIC_NPM_REGISTRY} for a newer published Directive release.`,
+    ];
+    let npmResult;
+    try {
+        npmResult = (options.runNpmView ?? defaultNpmView)();
+    }
+    catch {
+        npmResult = { ok: false, version: "" };
+    }
+    const availability = evaluateReleaseAvailability(installed, npmResult.ok ? npmResult.version : null);
+    if (availability.status !== "available")
+        return { lines };
+    const statePath = join(projectRoot, STATE_RELATIVE_PATH);
+    const state = parseState((options.readState ?? defaultReadText)(statePath));
+    const now = options.now ?? new Date();
+    if (isThrottled(state, availability.latestVersion, now))
+        return { lines: [] };
+    const message = `[deft release] Newer Directive release available: v${availability.latestVersion} ` +
+        `(installed v${availability.installedVersion}). Run \`npm i -g @deftai/directive@latest\`.`;
+    try {
+        (options.writeState ?? defaultWriteState)(statePath, `${JSON.stringify({ latestVersion: availability.latestVersion, notifiedAt: now.toISOString() }, null, 2)}\n`);
+    }
+    catch {
+        // The advisory remains useful if its best-effort throttle state cannot persist.
+    }
+    return { lines: [...lines, message] };
+}
+//# sourceMappingURL=release-availability.js.map

package/dist/session/ritual-sentinel.d.ts

@@ -43,6 +43,20 @@ export declare function newRitualStatePayload(input: {
 }): Record<string, unknown>;
 export declare function readRitualState(projectRoot: string): [RitualState | null, string | null];
 export declare function writeRitualState(projectRoot: string, payload: Record<string, unknown>): string;
+/** Instant guaranteed to fail `evaluateLoadedState` age checks on any policy horizon. */
+export declare const RITUAL_STALE_EPOCH: Date;
+export interface MarkRitualStaleAfterCompactResult {
+    readonly changed: boolean;
+    readonly statePath: string;
+    readonly message: string;
+}
+/**
+ * Invalidate an existing mutation ritual after host context compaction/resume (#2113).
+ * Reuses ritual-state age semantics — no parallel policy stack.
+ */
+export declare function markRitualStaleAfterCompact(projectRoot: string, input?: {
+    now?: Date;
+}): MarkRitualStaleAfterCompactResult;
 export declare function recordRitualStep(projectRoot: string, input: {
     tier: "quick" | "gated";
     stepName: string;

package/dist/session/ritual-sentinel.js

@@ -184,6 +184,34 @@ export function writeRitualState(projectRoot, payload) {
     atomicWriteJson(stateFile, payload, ".ritual-state.");
     return stateFile;
 }
+/** Instant guaranteed to fail `evaluateLoadedState` age checks on any policy horizon. */
+export const RITUAL_STALE_EPOCH = new Date("1970-01-01T00:00:00Z");
+/**
+ * Invalidate an existing mutation ritual after host context compaction/resume (#2113).
+ * Reuses ritual-state age semantics — no parallel policy stack.
+ */
+export function markRitualStaleAfterCompact(projectRoot, input = {}) {
+    const now = input.now ?? new Date();
+    const statePath = ritualStatePath(projectRoot);
+    const [state, err] = readRitualState(projectRoot);
+    if (state === null) {
+        return {
+            changed: false,
+            statePath,
+            message: err ?? "no ritual state to invalidate after compaction",
+        };
+    }
+    const payload = { ...state.raw };
+    payload.started_at = timestampIso(RITUAL_STALE_EPOCH);
+    payload.compact_resume_at = timestampIso(now);
+    writeRitualState(projectRoot, payload);
+    return {
+        changed: true,
+        statePath,
+        message: "Marked session ritual stale after context compaction; run session:start and " +
+            "verify:session-ritual -- --tier=gated before direct writes.",
+    };
+}
 export function recordRitualStep(projectRoot, input) {
     const [state, err] = readRitualState(projectRoot);
     if (state === null) {

package/dist/session/session-start.d.ts

@@ -1,6 +1,7 @@
 import { type EnvironmentContext } from "../platform/shell-context.js";
 import { type ResolveUserMdResult } from "../user-config/resolve-user-md.js";
 import type { GitRunner } from "./git.js";
+import { type ReleaseAvailabilityProbeOptions } from "./release-availability.js";
 import { ritualStatePath } from "./ritual-sentinel.js";
 export declare const SESSION_POSTURES: readonly ["read-only", "mutation"];
 export type SessionPosture = (typeof SESSION_POSTURES)[number];
@@ -42,6 +43,15 @@ export interface SessionStartOptions {
     };
     readonly resolveUserMd?: (projectRoot: string) => ResolveUserMdResult;
     readonly probeEnvironment?: () => EnvironmentContext;
+    readonly probeReleaseAvailability?: (projectRoot: string, options: ReleaseAvailabilityProbeOptions) => {
+        lines: readonly string[];
+    };
+    readonly runStalenessTickler?: (projectRoot: string, options: {
+        now?: Date;
+    }) => {
+        lines: readonly string[];
+        prompted: boolean;
+    };
 }
 export declare function parseDeferrals(rawValues: readonly string[]): {
     deferrals: Record<string, string>;

package/dist/session/session-start.js

@@ -5,11 +5,13 @@ import { MIGRATE_COMPLETION_NUDGE, shouldEmitMigrateNudge } from "../init-deposi
 import { detectEnvironmentContext, environmentContextToDict, formatEnvironmentContext, } from "../platform/shell-context.js";
 import { disclosureLine } from "../policy/disclosure.js";
 import { resolvePolicy } from "../policy/resolve.js";
+import { maybeRunStalenessTickler } from "../staleness-tickler/run.js";
 import { runDefaultMode } from "../triage/welcome/default-mode.js";
 import { resolveUserMdPath } from "../user-config/resolve-user-md.js";
 import { emitSessionValueReadback } from "../value/readback.js";
 import { verifyRequiredTools } from "../verify-env/verify-tools.js";
 import { defaultGitRunner, gitHead, worktreePath } from "./git.js";
+import { probeSessionReleaseAvailability, } from "./release-availability.js";
 import { newRitualStatePayload, ritualStatePath, ritualStep, writeRitualState, } from "./ritual-sentinel.js";
 export const SESSION_POSTURES = ["read-only", "mutation"];
 export const READ_ONLY_POSTURE = "read-only";
@@ -341,6 +343,22 @@ export function runSessionStart(projectRoot, options = {}) {
             lines.push(message);
         }
     }
+    try {
+        const releaseAvailability = (options.probeReleaseAvailability ?? probeSessionReleaseAvailability)(projectRoot, { now: instant });
+        lines.push(...releaseAvailability.lines);
+    }
+    catch {
+        // Release availability is a best-effort operator advisory, never a session blocker.
+    }
+    try {
+        const tickler = (options.runStalenessTickler ?? maybeRunStalenessTickler)(projectRoot, {
+            now: instant,
+        });
+        lines.push(...tickler.lines);
+    }
+    catch {
+        // Staleness tickler is best-effort and must never block session start.
+    }
     if (!runningInsideDeftRepo(projectRoot) && shouldEmitMigrateNudge(projectRoot)) {
         lines.push(MIGRATE_COMPLETION_NUDGE);
     }

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

@@ -0,0 +1,14 @@
+import type { DriftInputs, DriftScoreResult, StalenessTicklerPolicy, StalenessTicklerState, StalenessTicklerTier, XbriefSchemaDistance } from "./types.js";
+/** Compute a weighted drift score from independent axes (#2489). */
+export declare function scoreDrift(inputs: DriftInputs, policy: StalenessTicklerPolicy): number;
+/** Map drift inputs to an escalation tier using typed thresholds. */
+export declare function resolveTier(inputs: DriftInputs, policy: StalenessTicklerPolicy): StalenessTicklerTier;
+/** Hold the last known tier when detection is unverified (#2489 monotonicity). */
+export declare function holdTierOnUnverified(computedTier: StalenessTicklerTier, computedScore: number, state: StalenessTicklerState, directiveUnverified: boolean): DriftScoreResult;
+/** Snooze window widens with deferrals up to `maxWidenMultiplier`. */
+export declare function snoozeWindowMs(tier: StalenessTicklerTier, deferralCount: number, policy: StalenessTicklerPolicy): number;
+export declare function isSnoozeActive(state: StalenessTicklerState, now: Date): boolean;
+/** Assert tier re-prompts at idle even when a plain snooze would still be active. */
+export declare function shouldPromptDespiteSnooze(tier: StalenessTicklerTier, state: StalenessTicklerState): boolean;
+export declare function mergeHeldXbriefDistance(current: XbriefSchemaDistance, held: XbriefSchemaDistance | undefined): XbriefSchemaDistance;
+//# sourceMappingURL=escalation.d.ts.map

package/dist/staleness-tickler/escalation.js

@@ -0,0 +1,106 @@
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+/** Compute a weighted drift score from independent axes (#2489). */
+export function scoreDrift(inputs, policy) {
+    const { weights } = policy;
+    let score = 0;
+    if (inputs.directive.stale) {
+        if (inputs.directive.majorBehind) {
+            score += weights.directiveMajor;
+        }
+        score += inputs.directive.minorDistance * weights.directiveMinor;
+        score += inputs.directive.patchDistance * weights.directivePatch;
+    }
+    if (inputs.xbrief.stale) {
+        if (inputs.xbrief.distance === "behind-major") {
+            score += weights.schemaMajor;
+        }
+        else if (inputs.xbrief.distance === "behind-minor") {
+            score += weights.schemaMinor;
+        }
+    }
+    score += (inputs.ageMs / MS_PER_DAY) * weights.agePerDay;
+    score += inputs.deferralCount * weights.deferral;
+    return score;
+}
+function baseTierFromInputs(inputs, policy) {
+    const { tiers } = policy;
+    if (inputs.directive.majorBehind ||
+        inputs.xbrief.distance === "behind-major" ||
+        inputs.ageMs >= tiers.strongAgeMs) {
+        return "strong";
+    }
+    if (inputs.directive.minorDistance >= tiers.noticeMinorThreshold ||
+        inputs.xbrief.distance === "behind-minor") {
+        return "notice";
+    }
+    return "quiet";
+}
+/** Map drift inputs to an escalation tier using typed thresholds. */
+export function resolveTier(inputs, policy) {
+    const base = baseTierFromInputs(inputs, policy);
+    if (base === "strong" && inputs.deferralCount >= policy.tiers.assertDeferralCap) {
+        return "assert";
+    }
+    return base;
+}
+/** Hold the last known tier when detection is unverified (#2489 monotonicity). */
+export function holdTierOnUnverified(computedTier, computedScore, state, directiveUnverified) {
+    if (!directiveUnverified || state.lastTier === undefined) {
+        return { score: computedScore, tier: computedTier };
+    }
+    const heldTier = state.lastTier;
+    const heldScore = state.lastScore ?? computedScore;
+    const tierRank = (tier) => tier === "quiet" ? 0 : tier === "notice" ? 1 : tier === "strong" ? 2 : 3;
+    if (tierRank(heldTier) > tierRank(computedTier)) {
+        return { score: heldScore, tier: heldTier };
+    }
+    return { score: computedScore, tier: computedTier };
+}
+function baseSnoozeMs(tier, policy) {
+    switch (tier) {
+        case "quiet":
+            return policy.snooze.quietMs;
+        case "notice":
+            return policy.snooze.noticeMs;
+        case "strong":
+            return policy.snooze.strongMs;
+        case "assert":
+            return policy.snooze.strongMs;
+        default:
+            return policy.snooze.noticeMs;
+    }
+}
+/** Snooze window widens with deferrals up to `maxWidenMultiplier`. */
+export function snoozeWindowMs(tier, deferralCount, policy) {
+    const base = baseSnoozeMs(tier, policy);
+    const multiplier = Math.min(1 + deferralCount, Math.max(1, policy.snooze.maxWidenMultiplier));
+    if (tier === "assert") {
+        return Math.min(base, policy.snooze.strongMs);
+    }
+    return Math.round(base * multiplier);
+}
+export function isSnoozeActive(state, now) {
+    if (!state.snoozedUntil) {
+        return false;
+    }
+    const until = Date.parse(state.snoozedUntil);
+    return Number.isFinite(until) && now.getTime() < until;
+}
+/** Assert tier re-prompts at idle even when a plain snooze would still be active. */
+export function shouldPromptDespiteSnooze(tier, state) {
+    if (tier !== "assert") {
+        return false;
+    }
+    if (state.remindAfterNextRelease) {
+        return false;
+    }
+    return true;
+}
+export function mergeHeldXbriefDistance(current, held) {
+    if (held === undefined) {
+        return current;
+    }
+    const rank = (distance) => distance === "current" ? 0 : distance === "behind-minor" ? 1 : 2;
+    return rank(held) > rank(current) ? held : current;
+}
+//# sourceMappingURL=escalation.js.map

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

@@ -0,0 +1,18 @@
+import type { StalenessTicklerPolicy } from "./types.js";
+export interface IdleGateOptions {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly readPorcelain?: (projectRoot: string) => string | null;
+    readonly countInFlight?: (projectRoot: string) => number;
+    readonly insideDeftRepo?: (projectRoot: string) => boolean;
+}
+export interface IdleGateResult {
+    readonly ok: boolean;
+    readonly reason?: string;
+}
+/** True when every #2488 idle gate passes for an interactive tickler prompt. */
+export declare function isSafeIdlePoint(projectRoot: string, policy: StalenessTicklerPolicy, options?: IdleGateOptions): IdleGateResult;
+/** Skip the tickler entirely in CI/headless ritual-skip contexts. */
+export declare function shouldSkipTicklerEntirely(env?: NodeJS.ProcessEnv): boolean;
+/** Whether stdin/stdout are TTYs suitable for a blocking consent prompt. */
+export declare function isInteractiveSession(env?: NodeJS.ProcessEnv, isTty?: () => boolean): boolean;
+//# sourceMappingURL=idle.d.ts.map

package/dist/staleness-tickler/idle.js

@@ -0,0 +1,47 @@
+import { runningInsideDeftRepo } from "../doctor/paths.js";
+import { gitPorcelain } from "../story-ready/git.js";
+import { countFilesystemInFlight } from "../triage/summary/index.js";
+function ritualSkipActive(env) {
+    return env.DEFT_SESSION_RITUAL_SKIP === "1";
+}
+/** True when every #2488 idle gate passes for an interactive tickler prompt. */
+export function isSafeIdlePoint(projectRoot, policy, options = {}) {
+    const env = options.env ?? process.env;
+    if (ritualSkipActive(env)) {
+        return { ok: false, reason: "DEFT_SESSION_RITUAL_SKIP=1" };
+    }
+    if (!policy.enabled || policy.optOut) {
+        return { ok: false, reason: "policy-disabled" };
+    }
+    const insideDeft = options.insideDeftRepo ?? ((root) => runningInsideDeftRepo(root));
+    if (insideDeft(projectRoot)) {
+        return { ok: false, reason: "framework-repo" };
+    }
+    const porcelain = (options.readPorcelain ?? gitPorcelain)(projectRoot);
+    if (porcelain === null) {
+        return { ok: false, reason: "git-undeterminable" };
+    }
+    if (porcelain.trim().length > 0) {
+        return { ok: false, reason: "dirty-tree" };
+    }
+    const inFlight = (options.countInFlight ?? countFilesystemInFlight)(projectRoot);
+    if (inFlight > 0) {
+        return { ok: false, reason: "story-in-flight" };
+    }
+    return { ok: true };
+}
+/** Skip the tickler entirely in CI/headless ritual-skip contexts. */
+export function shouldSkipTicklerEntirely(env = process.env) {
+    return ritualSkipActive(env);
+}
+/** Whether stdin/stdout are TTYs suitable for a blocking consent prompt. */
+export function isInteractiveSession(env = process.env, isTty = () => process.stdin.isTTY === true && process.stdout.isTTY === true) {
+    if (env.DEFT_SESSION_RITUAL_SKIP === "1") {
+        return false;
+    }
+    if (env.CI === "true" || env.CI === "1") {
+        return false;
+    }
+    return isTty();
+}
+//# sourceMappingURL=idle.js.map

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

@@ -0,0 +1,8 @@
+export * from "./escalation.js";
+export * from "./idle.js";
+export * from "./probe-directive.js";
+export * from "./probe-xbrief.js";
+export { DIRECTIVE_UPGRADE_COMMAND, maybeRunStalenessTickler, probeStalenessDimensions, XBRIEF_MIGRATE_COMMAND, } from "./run.js";
+export * from "./state.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/staleness-tickler/index.js

@@ -0,0 +1,8 @@
+export * from "./escalation.js";
+export * from "./idle.js";
+export * from "./probe-directive.js";
+export * from "./probe-xbrief.js";
+export { DIRECTIVE_UPGRADE_COMMAND, maybeRunStalenessTickler, probeStalenessDimensions, XBRIEF_MIGRATE_COMMAND, } from "./run.js";
+export * from "./state.js";
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,32 @@
+import { type ReleaseAvailabilityResult } from "../doctor/release-availability.js";
+import type { ParsedSemverCore } from "./types.js";
+export interface ProbeDirectiveOptions {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly readText?: (path: string) => string | null;
+    readonly isFile?: (path: string) => boolean;
+    readonly runNpmView?: () => {
+        ok: boolean;
+        version: string;
+    };
+}
+/** Parse `X.Y.Z` or `vX.Y.Z` core semver (ignores pre-release suffix). */
+export declare function parseSemverCore(version: string): ParsedSemverCore | null;
+export declare function computeDirectiveDistance(installedVersion: string, latestVersion: string): {
+    majorBehind: boolean;
+    minorDistance: number;
+    patchDistance: number;
+};
+export interface ProbeDirectiveResult {
+    readonly availability: ReleaseAvailabilityResult;
+    readonly majorBehind: boolean;
+    readonly minorDistance: number;
+    readonly patchDistance: number;
+    readonly stale: boolean;
+    readonly registryDisclosure: string;
+}
+/**
+ * Probe Directive payload staleness via the public npm registry (#1692 substrate).
+ * Skips network when `DEFT_NO_NETWORK=1`.
+ */
+export declare function probeDirectiveStaleness(projectRoot: string, options?: ProbeDirectiveOptions): ProbeDirectiveResult | null;
+//# sourceMappingURL=probe-directive.d.ts.map

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