@deftai/directive-core 0.88.0 → 0.89.0

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

package/dist/escalation/store.js

@@ -0,0 +1,172 @@
+/**
+ * Disk store for typed escalations under `.deft/escalations/` (#518).
+ */
+import { randomBytes } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, renameSync, rmSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
+import { assertWriteTargetSafe } from "../fs/projection-containment.js";
+import { escalationPath, escalationsDir } from "./paths.js";
+import { DEFAULT_SLA_HOURS, ESCALATION_DECISIONS, ESCALATION_SCHEMA_VERSION, ESCALATION_STATUSES, ESCALATION_TYPES, isEscalationType, } from "./types.js";
+export function utcIso(now) {
+    const dt = now ?? new Date();
+    return dt.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+/**
+ * Contained atomic JSON write for escalations (#2980 / Greptile P1).
+ * Containment root is projectRoot (not dirname(target)) so parent-symlink escape fails closed.
+ * Unique random temp names avoid PID-reuse collisions; rename is the atomic publish step.
+ */
+function writeJsonContained(projectRoot, targetPath, payload) {
+    const root = resolve(projectRoot);
+    const abs = resolve(targetPath);
+    // Refuse leaf/parent symlinks on the final path before temp+rename publish.
+    assertWriteTargetSafe(root, abs);
+    const dir = dirname(abs);
+    const tmpBase = `.${basename(abs)}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+    const tmp = join(dir, tmpBase);
+    try {
+        containedWrite({
+            root,
+            target: tmp,
+            data: `${JSON.stringify(payload, null, 2)}\n`,
+            mode: "create",
+        });
+        renameSync(tmp, abs);
+    }
+    catch (err) {
+        try {
+            rmSync(tmp, { force: true });
+        }
+        catch {
+            /* best-effort cleanup */
+        }
+        throw err;
+    }
+}
+function readString(rec, key) {
+    const v = rec[key];
+    return typeof v === "string" && v.trim().length > 0 ? v.trim() : null;
+}
+function readStringArray(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((x) => typeof x === "string" && x.trim().length > 0);
+}
+function readNumber(rec, key) {
+    const v = rec[key];
+    return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function parseResolution(raw) {
+    if (raw === null || raw === undefined)
+        return null;
+    const rec = record(raw);
+    if (rec === null)
+        return null;
+    const decision = readString(rec, "decision");
+    const resolvedAt = readString(rec, "resolvedAt") ?? readString(rec, "resolved_at") ?? utcIso();
+    const resolvedBy = readString(rec, "resolvedBy") ?? readString(rec, "resolved_by") ?? "operator";
+    if (decision === null || !ESCALATION_DECISIONS.includes(decision)) {
+        return null;
+    }
+    return {
+        decision: decision,
+        resolvedAt,
+        resolvedBy,
+        note: readString(rec, "note"),
+        answer: readString(rec, "answer"),
+    };
+}
+/**
+ * Parse an escalation JSON object.
+ * Returns null when type/status/required fields are invalid (tests reject invalid types).
+ */
+export function parseEscalation(raw) {
+    const rec = record(raw);
+    if (rec === null)
+        return null;
+    const id = readString(rec, "id");
+    const agentId = readString(rec, "agentId") ?? readString(rec, "agent_id");
+    const typeRaw = readString(rec, "type");
+    const title = readString(rec, "title");
+    if (id === null || agentId === null || typeRaw === null || title === null)
+        return null;
+    if (!isEscalationType(typeRaw))
+        return null;
+    const statusRaw = (readString(rec, "status") ?? "open").toLowerCase();
+    if (!ESCALATION_STATUSES.includes(statusRaw))
+        return null;
+    const body = typeof rec.body === "string" ? rec.body : "";
+    const contextRefs = readStringArray(rec.contextRefs ?? rec.context_refs);
+    const createdAt = readString(rec, "createdAt") ?? readString(rec, "created_at") ?? utcIso();
+    const sla = readNumber(rec, "slaHours") ??
+        readNumber(rec, "sla_hours") ??
+        DEFAULT_SLA_HOURS[typeRaw];
+    const dangerous = rec.dangerous === true;
+    const resolution = parseResolution(rec.resolution);
+    return {
+        schemaVersion: ESCALATION_SCHEMA_VERSION,
+        id,
+        agentId,
+        type: typeRaw,
+        title,
+        body,
+        contextRefs,
+        createdAt,
+        slaHours: sla > 0 ? sla : DEFAULT_SLA_HOURS[typeRaw],
+        status: statusRaw,
+        dangerous,
+        resolution,
+    };
+}
+/** Validate type string alone (unit tests + CLI). */
+export function validateEscalationType(type) {
+    const normalized = type.trim().toLowerCase();
+    if (!isEscalationType(normalized)) {
+        throw new Error(`invalid escalation type '${type}'; expected one of: ${ESCALATION_TYPES.join(", ")}`);
+    }
+    return normalized;
+}
+export function saveEscalation(projectRoot, event) {
+    writeJsonContained(projectRoot, escalationPath(projectRoot, event.id), event);
+}
+export function loadEscalation(projectRoot, escalationId) {
+    const path = escalationPath(projectRoot, escalationId);
+    if (!existsSync(path))
+        return null;
+    try {
+        return parseEscalation(JSON.parse(readFileSync(path, "utf8")));
+    }
+    catch {
+        return null;
+    }
+}
+export function listEscalations(projectRoot) {
+    const dir = escalationsDir(projectRoot);
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const name of readdirSync(dir)) {
+        if (!name.endsWith(".json"))
+            continue;
+        try {
+            const event = parseEscalation(JSON.parse(readFileSync(join(dir, name), "utf8")));
+            if (event !== null)
+                out.push(event);
+        }
+        catch {
+            // skip corrupt files
+        }
+    }
+    out.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    return out;
+}
+export function listOpenEscalations(projectRoot) {
+    return listEscalations(projectRoot).filter((e) => e.status === "open");
+}
+//# sourceMappingURL=store.js.map

package/dist/escalation/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Typed escalation events + local queue store (#518 slim / #2948 Wave 5).
+ *
+ * Full priority-inbox web UI and metrics remain residual — this module is the
+ * versioned schema + `.deft/escalations/` file queue for CLI batching.
+ */
+/** Fixed vocabulary of escalation reasons (#518). */
+export declare const ESCALATION_TYPES: readonly ["cmd_approval", "design_decision", "approval", "resource", "external", "question"];
+export type EscalationType = (typeof ESCALATION_TYPES)[number];
+/**
+ * Types eligible for `escalation:batch-approve`.
+ * design_decision / approval / resource / external stay individual resolve.
+ */
+export declare const BATCH_APPROVABLE_TYPES: readonly ["cmd_approval", "question"];
+export type BatchApprovableType = (typeof BATCH_APPROVABLE_TYPES)[number];
+export declare const ESCALATION_STATUSES: readonly ["open", "resolved"];
+export type EscalationStatus = (typeof ESCALATION_STATUSES)[number];
+export declare const ESCALATION_DECISIONS: readonly ["approved", "denied", "answered", "dismissed"];
+export type EscalationDecision = (typeof ESCALATION_DECISIONS)[number];
+/** Default SLA hours per type (issue #518 table). */
+export declare const DEFAULT_SLA_HOURS: Readonly<Record<EscalationType, number>>;
+export interface EscalationResolution {
+    readonly decision: EscalationDecision;
+    readonly resolvedAt: string;
+    readonly resolvedBy: string;
+    readonly note: string | null;
+    /** Free-text answer for `question` type (optional for other types). */
+    readonly answer: string | null;
+}
+/**
+ * Versioned escalation event (YAML shape from #518, camelCase on disk).
+ *
+ * ```json
+ * {
+ *   "schemaVersion": 1,
+ *   "id": "esc-…",
+ *   "agentId": "agent-b",
+ *   "type": "design_decision",
+ *   "title": "…",
+ *   "body": "…",
+ *   "contextRefs": ["xbrief/…", "#496"],
+ *   "createdAt": "2026-07-30T10:00:00Z",
+ *   "slaHours": 4,
+ *   "status": "open",
+ *   "dangerous": false,
+ *   "resolution": null
+ * }
+ * ```
+ */
+export interface EscalationEvent {
+    readonly schemaVersion: 1;
+    readonly id: string;
+    readonly agentId: string;
+    readonly type: EscalationType;
+    readonly title: string;
+    readonly body: string;
+    readonly contextRefs: readonly string[];
+    readonly createdAt: string;
+    readonly slaHours: number;
+    readonly status: EscalationStatus;
+    /**
+     * When true, batch-approve skips this item unless `--include-dangerous`.
+     * Use for shell write-scope cmd_approval, PR merges, and similar.
+     */
+    readonly dangerous: boolean;
+    readonly resolution: EscalationResolution | null;
+}
+export declare const ESCALATION_SCHEMA_VERSION: 1;
+export declare const ESCALATION_DIR = ".deft/escalations";
+export declare function isEscalationType(value: string): value is EscalationType;
+export declare function isBatchApprovableType(type: EscalationType): type is BatchApprovableType;
+export declare function isEscalationDecision(value: string): value is EscalationDecision;
+//# sourceMappingURL=types.d.ts.map

package/dist/escalation/types.js

@@ -0,0 +1,43 @@
+/**
+ * Typed escalation events + local queue store (#518 slim / #2948 Wave 5).
+ *
+ * Full priority-inbox web UI and metrics remain residual — this module is the
+ * versioned schema + `.deft/escalations/` file queue for CLI batching.
+ */
+/** Fixed vocabulary of escalation reasons (#518). */
+export const ESCALATION_TYPES = [
+    "cmd_approval",
+    "design_decision",
+    "approval",
+    "resource",
+    "external",
+    "question",
+];
+/**
+ * Types eligible for `escalation:batch-approve`.
+ * design_decision / approval / resource / external stay individual resolve.
+ */
+export const BATCH_APPROVABLE_TYPES = ["cmd_approval", "question"];
+export const ESCALATION_STATUSES = ["open", "resolved"];
+export const ESCALATION_DECISIONS = ["approved", "denied", "answered", "dismissed"];
+/** Default SLA hours per type (issue #518 table). */
+export const DEFAULT_SLA_HOURS = {
+    cmd_approval: 1,
+    design_decision: 4,
+    approval: 4,
+    resource: 4,
+    external: 72,
+    question: 24,
+};
+export const ESCALATION_SCHEMA_VERSION = 1;
+export const ESCALATION_DIR = ".deft/escalations";
+export function isEscalationType(value) {
+    return ESCALATION_TYPES.includes(value);
+}
+export function isBatchApprovableType(type) {
+    return BATCH_APPROVABLE_TYPES.includes(type);
+}
+export function isEscalationDecision(value) {
+    return ESCALATION_DECISIONS.includes(value);
+}
+//# sourceMappingURL=types.js.map

package/dist/eval/crud-telemetry.js

@@ -1,6 +1,7 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
-import { dirname } from "node:path";
+import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
 import { readCorePackageVersion } from "../engine-version.js";
+import { containedWrite } from "../fs/contained-write.js";
 import { helpedMetricsHistoryPath } from "../metrics/resolve-metrics-home.js";
 import { scanVbrief } from "../vbrief-validate/conformance.js";
 import { validateVbriefSchema } from "../vbrief-validate/schema.js";
@@ -83,8 +84,19 @@ function assessDocument(path, parsed) {
 function sanitizeInlineMessage(message) {
     return message.replace(/\r?\n/g, " ");
 }
-function ensureParentDir(path) {
-    mkdirSync(dirname(path), { recursive: true });
+/**
+ * Contained replace under the target's parent directory (#2980 wave C).
+ * Metrics/CRUD sinks may live outside the project tree (platform metrics home).
+ */
+function containedReplaceAt(path, content) {
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    containedWrite({
+        root: resolve(dir),
+        target: basename(path),
+        data: content,
+        mode: "replace",
+    });
 }
 /** Absolute path to the versioned CRUD metrics ledger (#1703 Tier 1 / #2545). */
 export function crudMetricsHistoryPath(projectRoot) {
@@ -99,9 +111,17 @@ export function persistCrudMetrics(projectRoot, metrics) {
     if (path === null) {
         return;
     }
-    mkdirSync(dirname(path), { recursive: true });
+    // #2980 wave C: product write sink routes through containedWrite.
+    // Metrics home is often outside the project tree (#2545) — contain under ledger parent.
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
     for (const metric of metrics) {
-        appendFileSync(path, `${JSON.stringify(metric)}\n`, "utf8");
+        containedWrite({
+            root: resolve(dir),
+            target: basename(path),
+            data: `${JSON.stringify(metric)}\n`,
+            mode: "append",
+        });
     }
 }
 /**
@@ -155,8 +175,8 @@ export class InstrumentedVbriefCrud {
         if (!assessment.schemaValid) {
             return { ok: false, error: assessment.schemaErrors.join("; ") };
         }
-        ensureParentDir(path);
-        writeFileSync(path, content, "utf8");
+        // #2980 wave C: product write sink routes through containedWrite.
+        containedReplaceAt(path, content);
         return { ok: true };
     }
     read(path) {
@@ -244,8 +264,8 @@ export class InstrumentedVbriefCrud {
         if (!assessment.schemaValid && !options.trustedWrite) {
             return { ok: false, error: assessment.schemaErrors.join("; ") };
         }
-        ensureParentDir(path);
-        writeFileSync(path, content, "utf8");
+        // #2980 wave C: product write sink routes through containedWrite.
+        containedReplaceAt(path, content);
         return { ok: true };
     }
     /** Record update metrics without persisting (caller owns validated atomic write). */

package/dist/eval/health.js

@@ -1,9 +1,9 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
-import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
 import { agentsRefreshPlan } from "../doctor/agents-md.js";
 import { evaluate as evaluateEncoding } from "../encoding/evaluate.js";
 import { readCorePackageVersion } from "../engine-version.js";
-import { assertWriteTargetSafe } from "../fs/projection-containment.js";
+import { containedWrite } from "../fs/contained-write.js";
 import { resolveProjectDefinitionPath } from "../layout/resolve.js";
 import { healthMetricsHistoryPath } from "../metrics/resolve-metrics-home.js";
 import { readPlanPolicy } from "../policy/plan-extensions.js";
@@ -163,14 +163,29 @@ export function persistHealthRun(projectRoot, report) {
     if (path === null) {
         return;
     }
+    // #2980 wave C: product write sink routes through containedWrite.
+    // Project-local metrics: contain under projectRoot. Platform/env home: under ledger parent.
     const projectAbs = resolve(projectRoot);
     const targetAbs = resolve(path);
     const rel = relative(projectAbs, targetAbs);
-    if (rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel)) {
-        assertWriteTargetSafe(projectRoot, path);
+    const nested = rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel);
+    if (nested) {
+        containedWrite({
+            root: projectAbs,
+            target: targetAbs,
+            data: `${JSON.stringify(report)}\n`,
+            mode: "append",
+        });
+        return;
     }
-    mkdirSync(dirname(path), { recursive: true });
-    appendFileSync(path, `${JSON.stringify(report)}\n`, "utf8");
+    const parent = dirname(targetAbs);
+    mkdirSync(parent, { recursive: true });
+    containedWrite({
+        root: resolve(parent),
+        target: basename(targetAbs),
+        data: `${JSON.stringify(report)}\n`,
+        mode: "append",
+    });
 }
 function collectStaticGates(projectRoot, frameworkSource) {
     const gates = [

package/dist/eval/readback.js

@@ -1,6 +1,6 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
+import { containedWrite } from "../fs/contained-write.js";
 import { MAX_LINE_CHARS } from "../triage/welcome/constants.js";
 import { evaluateHealth, healthHistoryPath } from "./health.js";
 /** Repeat-suppression window for the budgeted eval session nudge (#1703 / #1279 parity). */
@@ -125,15 +125,16 @@ function appendEvalReadbackHistory(projectRoot, nudgeKey, line, options = {}) {
         line,
     };
     try {
-        assertWriteTargetSafe(projectRoot, path);
-        mkdirSync(join(path, ".."), { recursive: true });
-        appendFileSync(path, `${JSON.stringify(record)}\n`, "utf8");
+        // #2980 wave C: product write sink routes through containedWrite.
+        containedWrite({
+            root: resolve(projectRoot),
+            target: path,
+            data: `${JSON.stringify(record)}\n`,
+            mode: "append",
+        });
     }
-    catch (err) {
-        if (err instanceof ProjectionContainmentError) {
-            throw err;
-        }
-        // observability only
+    catch {
+        // observability only (containment refusals included — outer caller may swallow)
     }
 }
 function failedGateCount(report) {