@deftai/directive-core 0.87.0 → 0.89.0

package/dist/doctor/doctor-state.js

@@ -1,6 +1,7 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
 import { resolveTriageCachePath } from "../triage/cache-path.js";
 import { CLEAN_WINDOW_HOURS, DIRTY_WINDOW_HOURS, ENV_STATE_PATH } from "./constants.js";
 const STATE_FILENAME = "doctor-state.json";
@@ -57,8 +58,31 @@ export function writeState(projectRoot, payload) {
     };
     const path = statePath(projectRoot);
     try {
-        mkdirSync(dirname(path), { recursive: true });
-        writeFileSync(path, `${JSON.stringify(body, null, 2)}\n`, "utf8");
+        // #2980 wave C: product write sink routes through containedWrite.
+        // Default path is under the project triage cache; ENV_STATE_PATH may point outside.
+        const projectAbs = resolve(projectRoot);
+        const pathAbs = resolve(path);
+        const rel = relative(projectAbs, pathAbs);
+        const nested = rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel);
+        const payload = `${JSON.stringify(body, null, 2)}\n`;
+        if (nested) {
+            containedWrite({
+                root: projectAbs,
+                target: pathAbs,
+                data: payload,
+                mode: "replace",
+            });
+        }
+        else {
+            const parent = dirname(pathAbs);
+            mkdirSync(parent, { recursive: true });
+            containedWrite({
+                root: resolve(parent),
+                target: basename(pathAbs),
+                data: payload,
+                mode: "replace",
+            });
+        }
         return path;
     }
     catch {

package/dist/doctor/main.d.ts

@@ -4,6 +4,16 @@ import type { DoctorSeams, Finding, ResolutionSummary } from "./types.js";
 export declare function cmdDoctor(args: readonly string[], seams?: DoctorSeams): number;
 export declare function runAgentHooksHealthCheck(projectRoot: string, consumerContext: boolean, sink: ReturnType<typeof createPlainSink>, addFinding: (finding: Finding) => void, seams: DoctorSeams): boolean;
 export declare function runAgentHooksLiveProbeCheck(projectRoot: string, sink: ReturnType<typeof createPlainSink>, addFinding: (finding: Finding) => void, seams: DoctorSeams): void;
+/**
+ * Fail closed when PROJECT-DEFINITION under an xbrief/ layout still declares
+ * envelope 0.6 while the framework schema is 0.8 (#2971). Greenfield (no
+ * project definition yet) and current 0.8 envelopes pass. Unreadable paths
+ * (test seams / permission) skip rather than false-positive fail. Behind-major
+ * records `deft migrate:xbrief` as the next action — layout rename alone is not
+ * enough. Distinct from deposited-schema (`stale-xbrief-schema-deposit`) which
+ * must NOT route to migrate:xbrief when only framework schema files are stale.
+ */
+export declare function runXbriefEnvelopeVersionCheck(projectRoot: string, sink: ReturnType<typeof createPlainSink>, addFinding: (f: Finding) => void, seams: DoctorSeams): void;
 /**
  * Never emit a bare `task ...` remediation in a project without Taskfile wiring
  * (#2267 / #2893). The `directive`/`deft` surface always works; `task deft:X` is

package/dist/doctor/main.js

@@ -1,13 +1,18 @@
 import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { VBRIEF_VERSION } from "@deftai/directive-types";
 import { evaluate as evaluateAgentsMdAdvisory } from "../agents-md-advisory/evaluate.js";
 import { contentRoot } from "../content-root.js";
+import { resolveProjectDefinitionPath } from "../layout/resolve.js";
+import { detectNoDeftDirective, NO_DEFT_DIRECTIVE_DISABLED_MESSAGE, NO_DEFT_DIRECTIVE_FLAG_NAME, NO_DEFT_DIRECTIVE_INCONSISTENT_MESSAGE, NO_DEFT_DIRECTIVE_INCONSISTENT_POLICY, } from "../policy/no-deft-directive.js";
 import { describeShadowedPlanExtension, detectShadowedPlanExtensions, } from "../policy/plan-extensions.js";
 import { loadProjectDefinition } from "../policy/resolve.js";
 import { checkLocalEngineIntegrity, classify, detectPackageManager, evaluateSkew, reconcileVersions, plan as resolvePlan, } from "../resolution/index.js";
+import { classifyXbriefSchemaDistance } from "../staleness-tickler/probe-xbrief.js";
 import { resolveUserMdPath } from "../user-config/resolve-user-md.js";
 import { evaluateAgentHooks } from "../verify-env/agent-hooks.js";
 import { probeAgentHooksLive } from "../verify-env/agent-hooks-live-probe.js";
+import { readDeclaredArtifactVersion } from "../xbrief-migrate/transforms.js";
 import { agentsRefreshPlan, hasV3ManagedMarker } from "./agents-md.js";
 import { runChecks } from "./checks.js";
 import { CONSUMER_FRAMEWORK_DIRS, EXPECTED_CONTENT_DIRS, EXPECTED_FRAMEWORK_DIRS, NETWORK_DISCLOSURE_LINE, PAYLOAD_STALENESS_OFFLINE_SKIP_MESSAGE, TASKFILE_INCLUDE_SNIPPET, UV_INSTALL_URL, } from "./constants.js";
@@ -23,6 +28,8 @@ import { runLocalSignpostChecks } from "./signpost-checks.js";
 import { classifyTaskfileInclude, formatGatesSurfaceDualRemediation, formatMissingIncludeSnippet, GATES_SURFACE_DEFT_REMEDIATION, includesBlockHasDeftTaskfile, resolveConsumerTaskfile, } from "./taskfile.js";
 import { defaultWhich } from "./which.js";
 const DEFAULT_RESOLUTION_PLATFORMS = ["linux", "darwin", "win32"];
+/** Next-action command for project-envelope behind-major (#2971). */
+const XBRIEF_ENVELOPE_MIGRATE_COMMAND = "deft migrate:xbrief";
 /**
  * Read the `packageManager` field (Corepack) from a project package.json, or
  * null when absent/unreadable. Lets the doctor detect a pnpm project that has
@@ -62,6 +69,53 @@ export function cmdDoctor(args, seams = {}) {
     const consumerContext = resolve(projectRoot) !== resolve(frameworkRoot);
     const whichFn = seams.whichFn ?? defaultWhich;
     const nowFn = seams.now ?? (() => new Date());
+    // #2926: official root opt-out — short-circuit Directive doctor when clean;
+    // diagnose flag+deposit inconsistency (warn; exit dirty).
+    const optOut = detectNoDeftDirective(projectRoot);
+    if (optOut.present) {
+        if (optOut.inconsistent) {
+            const message = `${NO_DEFT_DIRECTIVE_INCONSISTENT_MESSAGE} (${NO_DEFT_DIRECTIVE_DISABLED_MESSAGE})`;
+            if (jsonMode) {
+                const payload = {
+                    status: "disabled-inconsistent",
+                    disabled: true,
+                    disabled_via: NO_DEFT_DIRECTIVE_FLAG_NAME,
+                    inconsistent: true,
+                    inconsistent_policy: NO_DEFT_DIRECTIVE_INCONSISTENT_POLICY,
+                    deposit_present: true,
+                    message,
+                    findings: [
+                        {
+                            severity: "warning",
+                            message,
+                            check: "no-deft-directive",
+                            policy: NO_DEFT_DIRECTIVE_INCONSISTENT_POLICY,
+                        },
+                    ],
+                };
+                process.stdout.write(`${pythonJsonDump(payload)}\n`);
+            }
+            else if (!quietMode) {
+                process.stderr.write(`${message} [policy=${NO_DEFT_DIRECTIVE_INCONSISTENT_POLICY}]\n`);
+            }
+            return 1;
+        }
+        if (jsonMode) {
+            const payload = {
+                status: "disabled",
+                disabled: true,
+                disabled_via: NO_DEFT_DIRECTIVE_FLAG_NAME,
+                inconsistent: false,
+                deposit_present: false,
+                message: NO_DEFT_DIRECTIVE_DISABLED_MESSAGE,
+            };
+            process.stdout.write(`${pythonJsonDump(payload)}\n`);
+        }
+        else if (!quietMode) {
+            process.stdout.write(`${NO_DEFT_DIRECTIVE_DISABLED_MESSAGE}\n`);
+        }
+        return 0;
+    }
     if (!fullMode) {
         const state = (seams.readState ?? readState)(projectRoot);
         const decision = decideThrottle(state, nowFn());
@@ -293,6 +347,11 @@ export function cmdDoctor(args, seams = {}) {
     }
     sink.info("Checking gates-surface readiness (Taskfile include for deep-think agent gates)...");
     runTaskfileIncludeCheck(projectRoot, fixMode, jsonMode, sink, addFinding, seams);
+    if (!jsonMode) {
+        sink.blank();
+    }
+    sink.info("Checking xBRIEF project envelope version...");
+    runXbriefEnvelopeVersionCheck(projectRoot, sink, addFinding, seams);
     let resolution = null;
     if (!runningInsideDeftRepo(projectRoot, seams)) {
         if (!jsonMode) {
@@ -722,6 +781,155 @@ function runTaskfileIncludeCheck(projectRoot, fixMode, jsonMode, sink, addFindin
         suggestion: GATES_SURFACE_DEFT_REMEDIATION,
     });
 }
+/**
+ * Fail closed when PROJECT-DEFINITION under an xbrief/ layout still declares
+ * envelope 0.6 while the framework schema is 0.8 (#2971). Greenfield (no
+ * project definition yet) and current 0.8 envelopes pass. Unreadable paths
+ * (test seams / permission) skip rather than false-positive fail. Behind-major
+ * records `deft migrate:xbrief` as the next action — layout rename alone is not
+ * enough. Distinct from deposited-schema (`stale-xbrief-schema-deposit`) which
+ * must NOT route to migrate:xbrief when only framework schema files are stale.
+ */
+export function runXbriefEnvelopeVersionCheck(projectRoot, sink, addFinding, seams) {
+    const checkName = "xbrief-envelope-version";
+    const isFile = seams.isFile ?? ((p) => existsSync(p));
+    const readText = seams.readText ?? readTextSafe;
+    const targetVersion = VBRIEF_VERSION;
+    if (seams.probeXbriefEnvelope) {
+        const probe = seams.probeXbriefEnvelope(projectRoot);
+        emitXbriefEnvelopeFinding(checkName, probe, sink, addFinding);
+        return;
+    }
+    let definitionPath;
+    try {
+        definitionPath = resolveProjectDefinitionPath(projectRoot);
+    }
+    catch {
+        // Pure vbrief/-only trees are already covered by layout migrate signposts.
+        const skipMessage = `${checkName}: skip -- legacy-only layout (use layout migrate first)`;
+        sink.info(skipMessage);
+        addFinding({
+            severity: "skip",
+            message: skipMessage,
+            check: checkName,
+            status: "skip",
+            reason: "legacy-only-layout",
+        });
+        return;
+    }
+    if (!isFile(definitionPath)) {
+        const skipMessage = `${checkName}: skip -- no PROJECT-DEFINITION yet (greenfield)`;
+        sink.info(skipMessage);
+        addFinding({
+            severity: "skip",
+            message: skipMessage,
+            check: checkName,
+            status: "skip",
+            reason: "no-project-definition",
+        });
+        return;
+    }
+    const text = readText(definitionPath);
+    if (text === null) {
+        // Unreadable path (permissions or injectable seams) is not proof of 0.6.
+        const skipMessage = `${checkName}: skip -- PROJECT-DEFINITION unreadable`;
+        sink.info(skipMessage);
+        addFinding({
+            severity: "skip",
+            message: skipMessage,
+            check: checkName,
+            status: "skip",
+            reason: "unreadable",
+        });
+        return;
+    }
+    let declaredVersion = null;
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+            declaredVersion = readDeclaredArtifactVersion(parsed);
+        }
+        else {
+            const skipMessage = `${checkName}: skip -- PROJECT-DEFINITION is not a JSON object`;
+            sink.info(skipMessage);
+            addFinding({
+                severity: "skip",
+                message: skipMessage,
+                check: checkName,
+                status: "skip",
+                reason: "invalid-json-shape",
+            });
+            return;
+        }
+    }
+    catch {
+        const skipMessage = `${checkName}: skip -- PROJECT-DEFINITION JSON parse failed`;
+        sink.info(skipMessage);
+        addFinding({
+            severity: "skip",
+            message: skipMessage,
+            check: checkName,
+            status: "skip",
+            reason: "parse-error",
+        });
+        return;
+    }
+    const distance = classifyXbriefSchemaDistance(declaredVersion, targetVersion);
+    emitXbriefEnvelopeFinding(checkName, {
+        declaredVersion,
+        targetVersion,
+        distance,
+        stale: distance !== "current",
+    }, sink, addFinding);
+}
+function emitXbriefEnvelopeFinding(checkName, probe, sink, addFinding) {
+    if (probe.distance === "current") {
+        const okMessage = `${checkName}: current -- xBRIEFInfo@${probe.declaredVersion ?? probe.targetVersion} ` +
+            `(framework ${probe.targetVersion})`;
+        sink.success(okMessage);
+        addFinding({
+            severity: "skip",
+            message: okMessage,
+            check: checkName,
+            status: "current",
+            declared_version: probe.declaredVersion,
+            target_version: probe.targetVersion,
+        });
+        return;
+    }
+    if (probe.distance === "behind-minor") {
+        const warnMessage = `${checkName}: behind-minor -- declared ${probe.declaredVersion ?? "unknown"}, ` +
+            `framework ${probe.targetVersion}. Prefer \`deft migrate:xbrief\` when convenient.`;
+        sink.warn(warnMessage);
+        addFinding({
+            severity: "warning",
+            message: warnMessage,
+            check: checkName,
+            status: "behind-minor",
+            suggestion: XBRIEF_ENVELOPE_MIGRATE_COMMAND,
+            declared_version: probe.declaredVersion,
+            target_version: probe.targetVersion,
+            next_command: XBRIEF_ENVELOPE_MIGRATE_COMMAND,
+        });
+        return;
+    }
+    // behind-major (declared 0.6 vs framework 0.8, dual half-state, missing version)
+    const nextCommand = XBRIEF_ENVELOPE_MIGRATE_COMMAND;
+    const message = `${checkName}: behind-major -- declared ${probe.declaredVersion ?? "unknown"}, ` +
+        `framework ${probe.targetVersion}. Next action: run \`${nextCommand}\` to bump project ` +
+        `JSON envelopes to xBRIEFInfo@${probe.targetVersion} (layout rename alone is not enough).`;
+    sink.error(message);
+    addFinding({
+        severity: "error",
+        message,
+        check: checkName,
+        status: "behind-major",
+        suggestion: nextCommand,
+        declared_version: probe.declaredVersion,
+        target_version: probe.targetVersion,
+        next_command: nextCommand,
+    });
+}
 /**
  * Surface the resolved USER.md path + which search rung matched (#2271) so the
  * resolution boundary is visible in doctor output. Uses the shared first-hit-

package/dist/doctor/types.d.ts

@@ -150,5 +150,16 @@ export interface DoctorSeams {
     readonly evaluateAgentHooks?: (projectRoot: string) => AgentHookHealthResult;
     /** Live hook spawn probe for doctor --full (#2852). */
     readonly probeAgentHooksLive?: (projectRoot: string) => AgentHookLiveProbeResult;
+    /**
+     * xBRIEF project-envelope staleness probe (#2971). Injected so doctor can
+     * fail closed on 0.6 project JSON under an xbrief/ layout without re-deriving
+     * the shared `probeXbriefStaleness` path in tests.
+     */
+    readonly probeXbriefEnvelope?: (projectRoot: string) => {
+        readonly declaredVersion: string | null;
+        readonly targetVersion: string;
+        readonly distance: "current" | "behind-minor" | "behind-major";
+        readonly stale: boolean;
+    };
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/escalation/actions.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Operator-facing escalation actions: file, list, resolve, batch-approve (#518).
+ */
+import { type EscalationEvent, type EscalationType } from "./types.js";
+export interface FileEscalationInput {
+    readonly projectRoot: string;
+    readonly type: string;
+    readonly title: string;
+    readonly body?: string;
+    readonly agentId?: string;
+    readonly contextRefs?: readonly string[];
+    readonly slaHours?: number;
+    readonly dangerous?: boolean;
+    readonly id?: string;
+    readonly now?: Date;
+}
+export declare function fileEscalation(input: FileEscalationInput): EscalationEvent;
+export interface ResolveEscalationInput {
+    readonly projectRoot: string;
+    readonly id: string;
+    readonly decision: string;
+    readonly actor?: string;
+    readonly note?: string | null;
+    readonly answer?: string | null;
+    readonly now?: Date;
+}
+export type ResolveEscalationResult = {
+    readonly ok: true;
+    readonly event: EscalationEvent;
+} | {
+    readonly ok: false;
+    readonly code: "not-found" | "already-resolved" | "invalid-decision";
+    readonly message: string;
+};
+export declare function resolveEscalation(input: ResolveEscalationInput): ResolveEscalationResult;
+export interface BatchApproveInput {
+    readonly projectRoot: string;
+    /** Limit to these ids; empty/undefined = all open batch-eligible. */
+    readonly ids?: readonly string[];
+    readonly actor?: string;
+    readonly note?: string | null;
+    /** When false (default), skip `dangerous: true` items. */
+    readonly includeDangerous?: boolean;
+    readonly now?: Date;
+}
+export interface BatchApproveResult {
+    readonly approved: EscalationEvent[];
+    readonly skipped: Array<{
+        id: string;
+        reason: string;
+    }>;
+}
+/**
+ * Bulk-approve only `cmd_approval` and `question` open items.
+ * design_decision / approval / resource / external must use individual resolve.
+ * Dangerous items are skipped unless `includeDangerous` is true.
+ */
+export declare function batchApproveEscalations(input: BatchApproveInput): BatchApproveResult;
+export declare function listEscalationsFiltered(projectRoot: string, opts?: {
+    openOnly?: boolean;
+    type?: EscalationType;
+}): EscalationEvent[];
+//# sourceMappingURL=actions.d.ts.map

package/dist/escalation/actions.js

@@ -0,0 +1,137 @@
+/**
+ * Operator-facing escalation actions: file, list, resolve, batch-approve (#518).
+ */
+import { randomBytes } from "node:crypto";
+import { listEscalations, listOpenEscalations, loadEscalation, parseEscalation, saveEscalation, utcIso, validateEscalationType, } from "./store.js";
+import { BATCH_APPROVABLE_TYPES, DEFAULT_SLA_HOURS, ESCALATION_SCHEMA_VERSION, isBatchApprovableType, isEscalationDecision, } from "./types.js";
+function newEscalationId(now) {
+    const ts = (now ?? new Date())
+        .toISOString()
+        .replace(/[-:TZ.]/g, "")
+        .slice(0, 14);
+    const suffix = randomBytes(3).toString("hex");
+    return `esc-${ts}-${suffix}`;
+}
+export function fileEscalation(input) {
+    const type = validateEscalationType(input.type);
+    const title = input.title.trim();
+    if (title.length === 0) {
+        throw new Error("escalation title must be non-empty");
+    }
+    const createdAt = utcIso(input.now);
+    const event = {
+        schemaVersion: ESCALATION_SCHEMA_VERSION,
+        id: input.id?.trim() || newEscalationId(input.now),
+        agentId: (input.agentId ?? "agent").trim() || "agent",
+        type,
+        title,
+        body: input.body ?? "",
+        contextRefs: input.contextRefs ?? [],
+        createdAt,
+        slaHours: input.slaHours !== undefined && input.slaHours > 0 ? input.slaHours : DEFAULT_SLA_HOURS[type],
+        status: "open",
+        dangerous: input.dangerous === true,
+        resolution: null,
+    };
+    // Round-trip through parse to guarantee store shape.
+    const parsed = parseEscalation(event);
+    if (parsed === null) {
+        throw new Error("internal: filed escalation failed validation");
+    }
+    saveEscalation(input.projectRoot, parsed);
+    return parsed;
+}
+export function resolveEscalation(input) {
+    const decisionRaw = input.decision.trim().toLowerCase();
+    if (!isEscalationDecision(decisionRaw)) {
+        return {
+            ok: false,
+            code: "invalid-decision",
+            message: `invalid decision '${input.decision}'; expected one of: approved, denied, answered, dismissed`,
+        };
+    }
+    const existing = loadEscalation(input.projectRoot, input.id);
+    if (existing === null) {
+        return {
+            ok: false,
+            code: "not-found",
+            message: `escalation not found: ${input.id}`,
+        };
+    }
+    if (existing.status !== "open") {
+        return {
+            ok: false,
+            code: "already-resolved",
+            message: `escalation already resolved: ${input.id}`,
+        };
+    }
+    const resolved = {
+        ...existing,
+        status: "resolved",
+        resolution: {
+            decision: decisionRaw,
+            resolvedAt: utcIso(input.now),
+            resolvedBy: (input.actor ?? "operator").trim() || "operator",
+            note: input.note ?? null,
+            answer: input.answer ?? null,
+        },
+    };
+    saveEscalation(input.projectRoot, resolved);
+    return { ok: true, event: resolved };
+}
+/**
+ * Bulk-approve only `cmd_approval` and `question` open items.
+ * design_decision / approval / resource / external must use individual resolve.
+ * Dangerous items are skipped unless `includeDangerous` is true.
+ */
+export function batchApproveEscalations(input) {
+    const open = listOpenEscalations(input.projectRoot);
+    const idFilter = input.ids !== undefined && input.ids.length > 0
+        ? new Set(input.ids.map((x) => x.trim()).filter((x) => x.length > 0))
+        : null;
+    const approved = [];
+    const skipped = [];
+    for (const event of open) {
+        if (idFilter !== null && !idFilter.has(event.id)) {
+            continue;
+        }
+        if (!isBatchApprovableType(event.type)) {
+            skipped.push({
+                id: event.id,
+                reason: `type ${event.type} is not batch-approvable (use escalation:resolve); allowed bulk types: ${BATCH_APPROVABLE_TYPES.join(", ")}`,
+            });
+            continue;
+        }
+        if (event.dangerous && input.includeDangerous !== true) {
+            skipped.push({
+                id: event.id,
+                reason: "dangerous=true — resolve individually or pass --include-dangerous",
+            });
+            continue;
+        }
+        const decision = event.type === "question" ? "answered" : "approved";
+        const result = resolveEscalation({
+            projectRoot: input.projectRoot,
+            id: event.id,
+            decision,
+            actor: input.actor,
+            note: input.note ?? "batch-approve",
+            answer: event.type === "question" ? (input.note ?? "acknowledged") : null,
+            now: input.now,
+        });
+        if (result.ok) {
+            approved.push(result.event);
+        }
+        else {
+            skipped.push({ id: event.id, reason: result.message });
+        }
+    }
+    return { approved, skipped };
+}
+export function listEscalationsFiltered(projectRoot, opts = {}) {
+    const base = opts.openOnly === true ? listOpenEscalations(projectRoot) : listEscalations(projectRoot);
+    if (opts.type === undefined)
+        return base;
+    return base.filter((e) => e.type === opts.type);
+}
+//# sourceMappingURL=actions.js.map

package/dist/escalation/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Typed escalation channel — schema + local queue (#518 slim / #2948 Wave 5).
+ */
+export * from "./actions.js";
+export * from "./paths.js";
+export * from "./store.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/escalation/index.js

@@ -0,0 +1,8 @@
+/**
+ * Typed escalation channel — schema + local queue (#518 slim / #2948 Wave 5).
+ */
+export * from "./actions.js";
+export * from "./paths.js";
+export * from "./store.js";
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/escalation/paths.d.ts

@@ -0,0 +1,3 @@
+export declare function escalationsDir(projectRoot: string): string;
+export declare function escalationPath(projectRoot: string, escalationId: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/escalation/paths.js

@@ -0,0 +1,10 @@
+import { join } from "node:path";
+import { ESCALATION_DIR } from "./types.js";
+export function escalationsDir(projectRoot) {
+    return join(projectRoot, ...ESCALATION_DIR.split("/"));
+}
+export function escalationPath(projectRoot, escalationId) {
+    const safe = escalationId.replace(/[^a-zA-Z0-9._-]/g, "_");
+    return join(escalationsDir(projectRoot), `${safe}.json`);
+}
+//# sourceMappingURL=paths.js.map

package/dist/escalation/store.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Disk store for typed escalations under `.deft/escalations/` (#518).
+ */
+import { type EscalationEvent, type EscalationType } from "./types.js";
+export declare function utcIso(now?: Date): string;
+/**
+ * Parse an escalation JSON object.
+ * Returns null when type/status/required fields are invalid (tests reject invalid types).
+ */
+export declare function parseEscalation(raw: unknown): EscalationEvent | null;
+/** Validate type string alone (unit tests + CLI). */
+export declare function validateEscalationType(type: string): EscalationType;
+export declare function saveEscalation(projectRoot: string, event: EscalationEvent): void;
+export declare function loadEscalation(projectRoot: string, escalationId: string): EscalationEvent | null;
+export declare function listEscalations(projectRoot: string): EscalationEvent[];
+export declare function listOpenEscalations(projectRoot: string): EscalationEvent[];
+//# sourceMappingURL=store.d.ts.map