@deftai/directive-core 0.79.4 → 0.81.0

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/vbrief-validate/plan-hooks.d.ts

@@ -4,6 +4,10 @@ export declare function validateWipCapOnPlan(plan: unknown, filepath: string): s
 export declare function validateSessionRitualStalenessHoursOnPlan(plan: unknown, filepath: string): string[];
 /** vbrief_validate hook: validate ``plan.policy.triageRankingLabels`` (#1128). */
 export declare function validateTriageRankingLabelsOnPlan(plan: unknown, filepath: string): string[];
+/** vbrief_validate hook: validate ``plan.policy.runtimeAuthority`` (#1394). */
+export declare function validateRuntimeAuthorityOnPlan(plan: unknown, filepath: string): string[];
+/** vbrief_validate hook: validate ``plan.policy.stalenessTickler`` (#2489). */
+export declare function validateStalenessTicklerOnPlan(plan: unknown, filepath: string): string[];
 /** Run all PROJECT-DEFINITION policy hooks (mirrors lazy-import block in Python). */
 export declare function runProjectDefinitionHooks(plan: unknown, filepath: string): string[];
 //# sourceMappingURL=plan-hooks.d.ts.map

package/dist/vbrief-validate/plan-hooks.js

@@ -1,4 +1,6 @@
 import { readPlanPolicy } from "../policy/plan-extensions.js";
+import { validateRuntimeAuthority } from "../policy/runtime-authority.js";
+import { validateStalenessTickler } from "../policy/staleness-tickler.js";
 import { validateTriageAutoClassifyOnPlan, validateTriageHoldMarkersOnPlan, } from "../triage/classify/index.js";
 import { validateRankingLabels } from "../triage/queue/ranking-labels.js";
 import { pyStrRepr, pythonTypeName } from "../triage/scope/python-repr.js";
@@ -101,6 +103,42 @@ export function validateTriageRankingLabelsOnPlan(plan, filepath) {
     const { errors } = validateRankingLabels(raw);
     return errors.map((err) => `${filepath}: ${err} (#1128)`);
 }
+/** vbrief_validate hook: validate ``plan.policy.runtimeAuthority`` (#1394). */
+export function validateRuntimeAuthorityOnPlan(plan, filepath) {
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return [];
+    }
+    const policy = readPlanPolicy(plan);
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
+        return [];
+    }
+    if (!("runtimeAuthority" in policy)) {
+        return [];
+    }
+    const out = [];
+    for (const err of validateRuntimeAuthority(policy.runtimeAuthority)) {
+        out.push(`${filepath}: ${err} (#1394)`);
+    }
+    return out;
+}
+/** vbrief_validate hook: validate ``plan.policy.stalenessTickler`` (#2489). */
+export function validateStalenessTicklerOnPlan(plan, filepath) {
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return [];
+    }
+    const policy = readPlanPolicy(plan);
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
+        return [];
+    }
+    if (!("stalenessTickler" in policy)) {
+        return [];
+    }
+    const out = [];
+    for (const err of validateStalenessTickler(policy.stalenessTickler)) {
+        out.push(`${filepath}: ${err} (#2489)`);
+    }
+    return out;
+}
 /** Run all PROJECT-DEFINITION policy hooks (mirrors lazy-import block in Python). */
 export function runProjectDefinitionHooks(plan, filepath) {
     const errors = [];
@@ -141,6 +179,18 @@ export function runProjectDefinitionHooks(plan, filepath) {
     catch {
         /* hook must not break validation */
     }
+    try {
+        errors.push(...validateStalenessTicklerOnPlan(plan, filepath));
+    }
+    catch {
+        /* hook must not break validation */
+    }
+    try {
+        errors.push(...validateRuntimeAuthorityOnPlan(plan, filepath));
+    }
+    catch {
+        /* hook must not break validation */
+    }
     return errors;
 }
 //# sourceMappingURL=plan-hooks.js.map

package/dist/verify-env/agent-hooks.js

@@ -37,8 +37,10 @@ export function evaluateAgentHooks(projectRoot) {
     return {
         code: 0,
         message: "✓ deft agent hooks registered and structurally valid for Claude, Grok, Cursor, Codex " +
-            "(SessionStart + PreToolUse direct-write tools only; Codex runtime trust is " +
-            "user-controlled and must be reviewed with `/hooks`; shell/MCP policy is deferred).",
+            "(SessionStart + PreToolUse direct-write and spawn/Task tools; compact re-arm deposited for Claude/Grok/Cursor; " +
+            "Codex has no native compact hook — re-run session ritual manually after compaction). " +
+            'Read-only explore: prefer Grok role `default_capability_mode = "read-only"`; hooks also honor ' +
+            "DEFT_HOOK_READ_ONLY=1 and explore subagent_type. Codex runtime trust is user-controlled and must be reviewed with `/hooks`; shell/MCP policy is deferred.",
         stream: "stdout",
         registrations,
     };

package/package.json

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