@deftai/directive-core 0.88.0 → 0.90.0

package/dist/lifecycle/stats.js

@@ -0,0 +1,286 @@
+/**
+ * Local xBRIEF lifecycle folder stats for weekly process rollups (#2995).
+ *
+ * Filesystem-only inventory of `xbrief/{proposed,pending,active,completed,cancelled}/`.
+ * No network calls.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { hasArtifactSuffix, LEGACY_ARTIFACT_DIR, MIGRATED_ARTIFACT_DIR, } from "../layout/resolve.js";
+import { parseDurationMs } from "../triage/scope/duration.js";
+/** Lifecycle folders scanned for stats. */
+export const STATS_LIFECYCLE_FOLDERS = [
+    "proposed",
+    "pending",
+    "active",
+    "completed",
+    "cancelled",
+];
+/** Count semantics for WWYSYDH / process forms (stable strings for --json). */
+export const LIFECYCLE_STATS_SEMANTICS = {
+    promoted: "xbriefs currently in pending/ whose event time falls inside the --since window " +
+        "(promoted and still pending; later-activated work is not double-counted here).",
+    activated: "xbriefs currently in active/ whose event time falls inside the --since window " +
+        "(activated and still active).",
+    completed: "xbriefs currently in completed/ with plan.status completed (or unset, treated as completed) " +
+        "whose event time falls inside the --since window.",
+    cancelled_or_failed: "xbriefs currently in cancelled/, or in completed/ with plan.status failed, " +
+        "whose event time falls inside the --since window.",
+    still_active: "snapshot count of all xbriefs currently in active/ (not filtered by --since).",
+    event_time: "event time = most recent of plan.metadata.completedAt, plan.updated, and xBRIEFInfo/vBRIEFInfo.updated; " +
+        "else file mtime. Window is [as_of - since, as_of] inclusive of as_of.",
+    note: "Counts are current-folder membership, not full transition history. A brief that was " +
+        "promoted then activated in the same week appears under activated (and still_active), not promoted.",
+};
+function parseIso(value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return null;
+    }
+    const text = value.trim().endsWith("Z") ? `${value.trim().slice(0, -1)}+00:00` : value.trim();
+    const parsed = new Date(text);
+    if (Number.isNaN(parsed.getTime())) {
+        return null;
+    }
+    return parsed;
+}
+function readJsonObject(path) {
+    try {
+        const raw = readFileSync(path, "utf8");
+        const data = JSON.parse(raw);
+        if (typeof data !== "object" || data === null || Array.isArray(data)) {
+            return null;
+        }
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+function planOf(data) {
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return null;
+    }
+    return plan;
+}
+function infoUpdated(data) {
+    for (const key of ["xBRIEFInfo", "vBRIEFInfo"]) {
+        const info = data[key];
+        if (typeof info === "object" && info !== null && !Array.isArray(info)) {
+            const stamp = parseIso(info.updated);
+            if (stamp !== null) {
+                return stamp;
+            }
+        }
+    }
+    return null;
+}
+function completedAt(plan) {
+    const metadata = plan.metadata;
+    if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) {
+        return null;
+    }
+    return parseIso(metadata.completedAt);
+}
+/**
+ * Event time for window membership: most recent of completedAt / plan.updated /
+ * info.updated, else mtime. Preferring max (not completedAt-first) so a later
+ * cancel/restore transition is not stuck on a stale completion stamp.
+ */
+function eventTimeFor(data, plan, path) {
+    const candidates = [];
+    const completed = completedAt(plan);
+    if (completed !== null) {
+        candidates.push(completed);
+    }
+    const planUpdated = parseIso(plan.updated);
+    if (planUpdated !== null) {
+        candidates.push(planUpdated);
+    }
+    const info = infoUpdated(data);
+    if (info !== null) {
+        candidates.push(info);
+    }
+    if (candidates.length > 0) {
+        return new Date(Math.max(...candidates.map((d) => d.getTime())));
+    }
+    try {
+        return new Date(statSync(path).mtimeMs);
+    }
+    catch {
+        return null;
+    }
+}
+/** Stats root: xbrief/ if present, else legacy vbrief/ (read-only inventory), else canonical xbrief path. */
+function resolveStatsLifecycleRoot(projectRoot) {
+    const migrated = join(projectRoot, MIGRATED_ARTIFACT_DIR);
+    if (existsSync(migrated)) {
+        try {
+            if (statSync(migrated).isDirectory()) {
+                return migrated;
+            }
+        }
+        catch {
+            // fall through
+        }
+    }
+    const legacy = join(projectRoot, LEGACY_ARTIFACT_DIR);
+    if (existsSync(legacy)) {
+        try {
+            if (statSync(legacy).isDirectory()) {
+                return legacy;
+            }
+        }
+        catch {
+            // fall through
+        }
+    }
+    return migrated;
+}
+function statusOf(plan, folder) {
+    const raw = plan.status;
+    if (typeof raw === "string" && raw.trim().length > 0) {
+        return raw.trim();
+    }
+    if (folder === "completed") {
+        return "completed";
+    }
+    if (folder === "cancelled") {
+        return "cancelled";
+    }
+    if (folder === "pending") {
+        return "pending";
+    }
+    if (folder === "active") {
+        return "running";
+    }
+    return "proposed";
+}
+function inWindow(eventTime, windowStart, asOf) {
+    if (eventTime === null) {
+        return false;
+    }
+    const t = eventTime.getTime();
+    return t >= windowStart.getTime() && t <= asOf.getTime();
+}
+function emptyFolderTotals() {
+    return { proposed: 0, pending: 0, active: 0, completed: 0, cancelled: 0 };
+}
+function scanArtifacts(lifecycleRoot) {
+    const out = [];
+    for (const folder of STATS_LIFECYCLE_FOLDERS) {
+        const dir = join(lifecycleRoot, folder);
+        if (!existsSync(dir)) {
+            continue;
+        }
+        let names;
+        try {
+            names = readdirSync(dir)
+                .filter((name) => hasArtifactSuffix(name))
+                .sort();
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            const path = join(dir, name);
+            const data = readJsonObject(path);
+            if (data === null) {
+                continue;
+            }
+            const plan = planOf(data);
+            if (plan === null) {
+                continue;
+            }
+            out.push({
+                folder,
+                status: statusOf(plan, folder),
+                eventTime: eventTimeFor(data, plan, path),
+            });
+        }
+    }
+    return out;
+}
+function utcIso(dt) {
+    return `${dt.toISOString().slice(0, 19)}Z`;
+}
+/**
+ * Collect lifecycle folder stats for a project root.
+ * Offline / filesystem only.
+ */
+export function collectLifecycleStats(options) {
+    const sinceRaw = (options.since ?? "7d").trim() || "7d";
+    const sinceMs = parseDurationMs(sinceRaw);
+    const asOf = options.now ?? new Date();
+    const windowStart = new Date(asOf.getTime() - sinceMs);
+    const projectRoot = resolve(options.projectRoot);
+    const lifecycleRoot = resolveStatsLifecycleRoot(projectRoot);
+    const folder_totals = emptyFolderTotals();
+    let promoted = 0;
+    let activated = 0;
+    let completed = 0;
+    let cancelled_or_failed = 0;
+    let still_active = 0;
+    const records = existsSync(lifecycleRoot) ? scanArtifacts(lifecycleRoot) : [];
+    for (const rec of records) {
+        folder_totals[rec.folder] += 1;
+        if (rec.folder === "active") {
+            still_active += 1;
+        }
+        const win = inWindow(rec.eventTime, windowStart, asOf);
+        if (!win) {
+            continue;
+        }
+        if (rec.folder === "pending") {
+            promoted += 1;
+        }
+        else if (rec.folder === "active") {
+            activated += 1;
+        }
+        else if (rec.folder === "cancelled") {
+            cancelled_or_failed += 1;
+        }
+        else if (rec.folder === "completed") {
+            if (rec.status === "failed") {
+                cancelled_or_failed += 1;
+            }
+            else if (rec.status === "completed") {
+                completed += 1;
+            }
+            // Inconsistent statuses under completed/ (e.g. stale "running") are
+            // counted in folder_totals only — not in window metrics.
+        }
+    }
+    return {
+        since: sinceRaw,
+        since_ms: sinceMs,
+        as_of: utcIso(asOf),
+        window_start: utcIso(windowStart),
+        project_root: projectRoot,
+        lifecycle_root: lifecycleRoot,
+        promoted,
+        activated,
+        completed,
+        cancelled_or_failed,
+        still_active,
+        folder_totals: { ...folder_totals },
+        semantics: LIFECYCLE_STATS_SEMANTICS,
+    };
+}
+/** Format human-readable lifecycle stats text. */
+export function formatLifecycleStatsText(stats) {
+    const lines = [
+        `lifecycle:stats (since ${stats.since}, as of ${stats.as_of})`,
+        `  window: ${stats.window_start} → ${stats.as_of}`,
+        `  promoted: ${stats.promoted}`,
+        `  activated: ${stats.activated}`,
+        `  completed: ${stats.completed}`,
+        `  cancelled_or_failed: ${stats.cancelled_or_failed}`,
+        `  still_active: ${stats.still_active}`,
+        `  folder_totals: proposed=${stats.folder_totals.proposed} pending=${stats.folder_totals.pending} active=${stats.folder_totals.active} completed=${stats.folder_totals.completed} cancelled=${stats.folder_totals.cancelled}`,
+    ];
+    return `${lines.join("\n")}\n`;
+}
+/** Re-export duration parse for CLI error messaging. */
+export { parseDurationMs };
+//# sourceMappingURL=stats.js.map

package/dist/packs/pack-render.js

@@ -1,8 +1,21 @@
 /** Port of scripts/pack_render.py — content-pack projection renderer (#1294, #1295). */
-import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, writeFileSync, } from "node:fs";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { contentRoot } from "../content-root.js";
+import { containedWrite } from "../fs/contained-write.js";
+/** Write under the parent directory as containment root (#2980 wave D). */
+function writeContainedFile(output, text) {
+    const abs = resolve(output);
+    const dir = dirname(abs);
+    mkdirSync(dir, { recursive: true });
+    containedWrite({
+        root: dir,
+        target: basename(abs),
+        data: text,
+        mode: "replace",
+    });
+}
 export function resolveRepoRoot() {
     return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "..");
 }
@@ -382,8 +395,8 @@ export function renderFile(source) {
 }
 export function writeRender(source, output) {
     const text = renderFile(source);
-    mkdirSync(dirname(output), { recursive: true });
-    writeFileSync(output, text, "utf8");
+    // #2980 wave D: product write sink routes through containedWrite.
+    writeContainedFile(output, text);
     return text;
 }
 export function checkDrift(source, output) {
@@ -441,9 +454,9 @@ function runMultipack(packFilter, check) {
         process.stdout.write(`pack-drift: all ${targets.length} projection(s) in sync.\n`);
         return 0;
     }
+    // #2980 wave D: product write sinks route through containedWrite.
     for (const [_name, outPath, text] of targets) {
-        mkdirSync(dirname(outPath), { recursive: true });
-        writeFileSync(outPath, text, "utf8");
+        writeContainedFile(outPath, text);
     }
     process.stdout.write(`Rendered ${targets.length} projection(s) across ${Object.keys(RENDER_REGISTRY).length} pack(s).\n`);
     return 0;

package/dist/plan-sequence/store.js

@@ -1,5 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
 import { PLAN_SEQUENCE_FILENAME, parsePlanSequence } from "./types.js";
 export function planSequencePath(projectRoot) {
     return join(projectRoot, ".deft", PLAN_SEQUENCE_FILENAME);
@@ -14,8 +15,14 @@ export function readPlanSequence(projectRoot) {
 }
 export function writePlanSequence(projectRoot, sequence) {
     const path = planSequencePath(projectRoot);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, `${JSON.stringify(sequence, null, 2)}\n`, "utf8");
+    // #2980 wave D: product write sink routes through containedWrite.
+    const root = resolve(projectRoot);
+    containedWrite({
+        root,
+        target: path,
+        data: `${JSON.stringify(sequence, null, 2)}\n`,
+        mode: "replace",
+    });
     return path;
 }
 export function clearPlanSequence(projectRoot) {

package/dist/policy/hotfix-criteria.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Typed hotfix classifier (#1193 R2 / Wave 2 of #2948).
+ *
+ * Hard structural predicates — not agent judgement. Agent may propose the
+ * label `hotfix-candidate` only; a human promotes to `hotfix`. Pipeline keys
+ * off `hotfix` exclusively; `hotfix-candidate` has zero pipeline meaning.
+ */
+import type { HotfixCriteria } from "@deftai/directive-types";
+export declare const FIELD_HOTFIX_CRITERIA = "plan.policy.hotfixCriteria";
+export declare const FIELD_HOTFIX_CRITERIA_CLI_ALIAS = "hotfixCriteria";
+/** Agent-proposed beacon only — never pipeline-authorizing. */
+export declare const HOTFIX_CANDIDATE_LABEL: "hotfix-candidate";
+/** Human-promoted label; deploy pipeline keys off this exclusively. */
+export declare const HOTFIX_LABEL: "hotfix";
+export declare const DEFAULT_HOTFIX_MAX_LINES = 10;
+export declare const DEFAULT_HOTFIX_MAX_FILES = 2;
+/** Paths that never qualify as hotfix (deploy / CI / migrations / secrets). */
+export declare const DEFAULT_FORBIDDEN_PATH_GLOBS: readonly string[];
+export declare const DEFAULT_HOTFIX_CRITERIA: Required<HotfixCriteria>;
+export interface HotfixEligibilityInput {
+    /** Total lines added+removed (or equivalent structural line count). */
+    readonly linesChanged: number;
+    /** Distinct files touched. */
+    readonly filesChanged: number;
+    /** Project-relative POSIX paths in the diff. */
+    readonly paths: readonly string[];
+    /** Pure revert of a prior change — always eligible. */
+    readonly isPureRevert?: boolean;
+    /** One-character / trivial edit signal (always eligible when true with restoresGreen). */
+    readonly isOneCharacterEdit?: boolean;
+    /** Refactors of any size are never hotfix. */
+    readonly isRefactor?: boolean;
+    /** New package / dependency entries. */
+    readonly addsNewDependency?: boolean;
+    /** Adds, removes, or renames an exported symbol/surface. */
+    readonly changesExportedSurface?: boolean;
+    /** Schema or migration changes. */
+    readonly touchesSchemaOrMigration?: boolean;
+    /** New handler/route/media-type surface. */
+    readonly addsNewHandlerOrRoute?: boolean;
+    /** Build was green on main; this change restores green. */
+    readonly restoresGreen?: boolean;
+    /** Criteria override (defaults + project typed policy). */
+    readonly criteria?: HotfixCriteria | null;
+}
+export type HotfixDenyReason = "refactor" | "new-export" | "new-dependency" | "schema-migration" | "new-handler-route" | "forbidden-path" | "too-many-lines" | "too-many-files" | "not-restoring-green";
+export interface HotfixEligibilityResult {
+    readonly eligible: boolean;
+    /** When eligible, the agent may apply this label only. */
+    readonly proposedLabel: typeof HOTFIX_CANDIDATE_LABEL | null;
+    readonly reasons: readonly string[];
+    readonly denyCodes: readonly HotfixDenyReason[];
+    readonly criteria: Required<HotfixCriteria>;
+}
+/**
+ * Pure hotfix eligibility evaluator (#1193 R2).
+ *
+ * Eligible (agent may propose `hotfix-candidate`):
+ * - pure revert always
+ * - one-character edit that restores green
+ * - small fix: ≤ maxLines AND ≤ maxFiles, no new deps/exports/schema, no forbidden
+ *   paths, not a refactor, restores green
+ *
+ * Never eligible: refactors, new handlers/routes, export surface changes, forbidden paths.
+ */
+export declare function evaluateHotfixEligibility(input: HotfixEligibilityInput): HotfixEligibilityResult;
+/** Resolve typed hotfixCriteria from a raw policy block value. */
+export declare function resolveHotfixCriteria(raw: unknown): Required<HotfixCriteria>;
+export interface HotfixCriteriaPolicyField {
+    readonly name: string;
+    readonly current: Required<HotfixCriteria>;
+    readonly default: Required<HotfixCriteria>;
+    readonly source: string;
+}
+/** Inspector row for `policy:show --field=hotfixCriteria`. */
+export declare function inspectHotfixCriteria(data: Record<string, unknown> | null): HotfixCriteriaPolicyField;
+/** Load hotfix criteria from project root. */
+export declare function loadHotfixCriteriaFromProject(projectRoot: string): Required<HotfixCriteria>;
+//# sourceMappingURL=hotfix-criteria.d.ts.map

package/dist/policy/hotfix-criteria.js

@@ -0,0 +1,197 @@
+/**
+ * Typed hotfix classifier (#1193 R2 / Wave 2 of #2948).
+ *
+ * Hard structural predicates — not agent judgement. Agent may propose the
+ * label `hotfix-candidate` only; a human promotes to `hotfix`. Pipeline keys
+ * off `hotfix` exclusively; `hotfix-candidate` has zero pipeline meaning.
+ */
+import { matchAny } from "../orchestration/pathspec.js";
+import { readPlanPolicy } from "./plan-extensions.js";
+import { loadProjectDefinition } from "./resolve.js";
+export const FIELD_HOTFIX_CRITERIA = "plan.policy.hotfixCriteria";
+export const FIELD_HOTFIX_CRITERIA_CLI_ALIAS = "hotfixCriteria";
+/** Agent-proposed beacon only — never pipeline-authorizing. */
+export const HOTFIX_CANDIDATE_LABEL = "hotfix-candidate";
+/** Human-promoted label; deploy pipeline keys off this exclusively. */
+export const HOTFIX_LABEL = "hotfix";
+export const DEFAULT_HOTFIX_MAX_LINES = 10;
+export const DEFAULT_HOTFIX_MAX_FILES = 2;
+/** Paths that never qualify as hotfix (deploy / CI / migrations / secrets). */
+export const DEFAULT_FORBIDDEN_PATH_GLOBS = [
+    "Dockerfile",
+    "**/Dockerfile",
+    "fly.toml",
+    "**/fly.toml",
+    ".github/workflows/**",
+    "migrations/**",
+    "**/migrations/**",
+    "**/*secret*",
+    "**/*billing*",
+    "**/.env",
+    "**/.env.*",
+    "**/auth/**",
+    "**/secrets/**",
+];
+export const DEFAULT_HOTFIX_CRITERIA = {
+    maxLines: DEFAULT_HOTFIX_MAX_LINES,
+    maxFiles: DEFAULT_HOTFIX_MAX_FILES,
+    forbiddenPathGlobs: DEFAULT_FORBIDDEN_PATH_GLOBS,
+};
+function normalizeCriteria(raw) {
+    const maxLines = typeof raw?.maxLines === "number" && Number.isInteger(raw.maxLines) && raw.maxLines >= 0
+        ? raw.maxLines
+        : DEFAULT_HOTFIX_MAX_LINES;
+    const maxFiles = typeof raw?.maxFiles === "number" && Number.isInteger(raw.maxFiles) && raw.maxFiles >= 0
+        ? raw.maxFiles
+        : DEFAULT_HOTFIX_MAX_FILES;
+    const forbidden = Array.isArray(raw?.forbiddenPathGlobs) && raw.forbiddenPathGlobs.length > 0
+        ? raw.forbiddenPathGlobs.filter((g) => typeof g === "string" && g.length > 0)
+        : DEFAULT_FORBIDDEN_PATH_GLOBS;
+    return { maxLines, maxFiles, forbiddenPathGlobs: forbidden };
+}
+function pathIsForbidden(path, globs) {
+    const posix = path.replace(/\\/g, "/");
+    // Basename-only defaults (Dockerfile, fly.toml) match any depth.
+    const base = posix.includes("/") ? posix.slice(posix.lastIndexOf("/") + 1) : posix;
+    for (const g of globs) {
+        if (!g.includes("/") && !g.includes("*") && base === g)
+            return true;
+    }
+    return matchAny(globs, posix);
+}
+/**
+ * Pure hotfix eligibility evaluator (#1193 R2).
+ *
+ * Eligible (agent may propose `hotfix-candidate`):
+ * - pure revert always
+ * - one-character edit that restores green
+ * - small fix: ≤ maxLines AND ≤ maxFiles, no new deps/exports/schema, no forbidden
+ *   paths, not a refactor, restores green
+ *
+ * Never eligible: refactors, new handlers/routes, export surface changes, forbidden paths.
+ */
+export function evaluateHotfixEligibility(input) {
+    const criteria = normalizeCriteria(input.criteria);
+    const denyCodes = [];
+    const reasons = [];
+    if (input.isPureRevert === true) {
+        return {
+            eligible: true,
+            proposedLabel: HOTFIX_CANDIDATE_LABEL,
+            reasons: ["pure-revert always qualifies as hotfix-candidate"],
+            denyCodes: [],
+            criteria,
+        };
+    }
+    if (input.isOneCharacterEdit === true && input.restoresGreen !== false) {
+        return {
+            eligible: true,
+            proposedLabel: HOTFIX_CANDIDATE_LABEL,
+            reasons: ["one-character edit that restores green qualifies as hotfix-candidate"],
+            denyCodes: [],
+            criteria,
+        };
+    }
+    if (input.isRefactor === true) {
+        denyCodes.push("refactor");
+        reasons.push("refactors of any size are never hotfix");
+    }
+    if (input.changesExportedSurface === true) {
+        denyCodes.push("new-export");
+        reasons.push("exported surface add/remove/rename is never hotfix");
+    }
+    if (input.addsNewDependency === true) {
+        denyCodes.push("new-dependency");
+        reasons.push("new dependencies are never hotfix");
+    }
+    if (input.touchesSchemaOrMigration === true) {
+        denyCodes.push("schema-migration");
+        reasons.push("schema/migration changes are never hotfix");
+    }
+    if (input.addsNewHandlerOrRoute === true) {
+        denyCodes.push("new-handler-route");
+        reasons.push("new handlers/routes/media types are never hotfix");
+    }
+    for (const p of input.paths) {
+        if (pathIsForbidden(p, criteria.forbiddenPathGlobs)) {
+            denyCodes.push("forbidden-path");
+            reasons.push(`forbidden path: ${p}`);
+            break;
+        }
+    }
+    if (input.linesChanged > criteria.maxLines) {
+        denyCodes.push("too-many-lines");
+        reasons.push(`linesChanged ${input.linesChanged} > maxLines ${criteria.maxLines}`);
+    }
+    if (input.filesChanged > criteria.maxFiles) {
+        denyCodes.push("too-many-files");
+        reasons.push(`filesChanged ${input.filesChanged} > maxFiles ${criteria.maxFiles}`);
+    }
+    // Small-fix path requires restoring green unless pure-revert/one-char already returned.
+    if (input.restoresGreen === false) {
+        denyCodes.push("not-restoring-green");
+        reasons.push("change does not restore green on main");
+    }
+    if (denyCodes.length > 0) {
+        return {
+            eligible: false,
+            proposedLabel: null,
+            reasons,
+            denyCodes,
+            criteria,
+        };
+    }
+    return {
+        eligible: true,
+        proposedLabel: HOTFIX_CANDIDATE_LABEL,
+        reasons: [
+            `small fix within limits (≤${criteria.maxLines} lines, ≤${criteria.maxFiles} files); ` +
+                "agent may apply hotfix-candidate only — human promotes hotfix",
+        ],
+        denyCodes: [],
+        criteria,
+    };
+}
+/** Resolve typed hotfixCriteria from a raw policy block value. */
+export function resolveHotfixCriteria(raw) {
+    if (raw === null || raw === undefined)
+        return { ...DEFAULT_HOTFIX_CRITERIA };
+    if (typeof raw !== "object" || Array.isArray(raw))
+        return { ...DEFAULT_HOTFIX_CRITERIA };
+    return normalizeCriteria(raw);
+}
+/** Inspector row for `policy:show --field=hotfixCriteria`. */
+export function inspectHotfixCriteria(data) {
+    const defaults = { ...DEFAULT_HOTFIX_CRITERIA };
+    if (data === null) {
+        return { name: FIELD_HOTFIX_CRITERIA, current: defaults, default: defaults, source: "default" };
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("hotfixCriteria" in policyBlock)) {
+        return { name: FIELD_HOTFIX_CRITERIA, current: defaults, default: defaults, source: "default" };
+    }
+    return {
+        name: FIELD_HOTFIX_CRITERIA,
+        current: resolveHotfixCriteria(policyBlock.hotfixCriteria),
+        default: defaults,
+        source: "typed",
+    };
+}
+/** Load hotfix criteria from project root. */
+export function loadHotfixCriteriaFromProject(projectRoot) {
+    const [data] = loadProjectDefinition(projectRoot);
+    if (data === null)
+        return { ...DEFAULT_HOTFIX_CRITERIA };
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("hotfixCriteria" in policyBlock)) {
+        return { ...DEFAULT_HOTFIX_CRITERIA };
+    }
+    return resolveHotfixCriteria(policyBlock.hotfixCriteria);
+}
+//# sourceMappingURL=hotfix-criteria.js.map

package/dist/policy/index.d.ts

@@ -4,17 +4,21 @@ export * from "./capacity.js";
 export * from "./decisions.js";
 export * from "./disclosure.js";
 export * from "./host-hooks.js";
+export * from "./hotfix-criteria.js";
+export * from "./intent-ceiling.js";
 export * from "./no-deft-directive.js";
 export * from "./org-force-on-migration.js";
 export * from "./plan-extensions.js";
 export * from "./policy-invocation.js";
 export * from "./product-signal.js";
+export * from "./require-human-merge.js";
 export * from "./resolve.js";
 export * from "./runtime-authority.js";
 export * from "./staleness-tickler.js";
 export * from "./value-feedback.js";
 export * from "./value-feedback-autoenable.js";
 export * from "./wip.js";
+export * from "./write-fence.js";
 export declare const FIELD_ALLOW_DIRECT_COMMITS = "plan.policy.allowDirectCommitsToMaster";
 export declare const FIELD_WIP_CAP = "plan.policy.wipCap";
 export declare const FIELD_SESSION_RITUAL_STALENESS_HOURS = "plan.policy.sessionRitualStalenessHours";