@deftai/directive-core 0.70.0 → 0.71.1

package/dist/value/readback.d.ts

@@ -0,0 +1,86 @@
+import { type BehavioralEventRecord } from "../lifecycle/events.js";
+import { type ValueFeedbackResolved } from "../policy/value-feedback.js";
+/** Repeat-suppression window for the budgeted session readback (#1709 / #1279 parity). */
+export declare const VALUE_READBACK_SUPPRESSION_HOURS = 4;
+export declare const VALUE_READBACK_HISTORY_REL: string;
+export declare const VALUE_READBACK_HISTORY_SCHEMA = "deft.value.readback.v1";
+export type SignalClass = "value" | "bypass" | "adoption" | "friction";
+export interface ReadAttributionOptions {
+    readonly projectRoot: string;
+    readonly logPath?: string | null;
+    readonly since?: Date | null;
+}
+export interface ValueShowTrend {
+    readonly windowLabel: string;
+    readonly windowMs: number;
+    readonly total: number;
+    readonly byClass: Readonly<Record<SignalClass, number>>;
+    readonly byEvent: Readonly<Record<string, number>>;
+    readonly recent: readonly BehavioralEventRecord[];
+}
+export interface ValueShowResult {
+    readonly exitCode: 0 | 1 | 2;
+    readonly gated: boolean;
+    readonly empty: boolean;
+    readonly text: string;
+    readonly trend: ValueShowTrend | null;
+}
+export interface SessionReadbackResult {
+    readonly line: string | null;
+    readonly suppressed: boolean;
+    readonly gated: boolean;
+}
+/** Read attribution ledger entries in emission order (#1709). */
+export declare function readAttributionEvents(options: ReadAttributionOptions): BehavioralEventRecord[];
+/** Format one attributed session line from a concrete ledger event (#1709 attributed-only). */
+export declare function formatAttributedSessionLine(record: BehavioralEventRecord): string;
+/** Pick the single highest-priority recent attribution for the session one-liner. */
+export declare function selectSessionAttribution(events: readonly BehavioralEventRecord[]): BehavioralEventRecord | null;
+/** True when the same attribution event id was read back within the suppression window. */
+export declare function shouldSuppressSessionReadback(eventId: string, historyFile: string, options?: {
+    now?: Date;
+}): boolean;
+/** Budgeted session one-liner — silent when gated, empty, or debounced (#1709). */
+export declare function renderSessionReadback(projectRoot: string, options?: {
+    policyOverride?: ValueFeedbackResolved;
+    logPath?: string | null;
+    now?: Date;
+    maxChars?: number;
+    writeHistory?: boolean;
+}): SessionReadbackResult;
+/** Emit the session readback line to stdout when present. Returns the line or null. */
+export declare function emitSessionValueReadback(projectRoot: string, options?: {
+    output?: (line: string) => void;
+    policyOverride?: ValueFeedbackResolved;
+    logPath?: string | null;
+    now?: Date;
+    writeHistory?: boolean;
+}): string | null;
+export declare function parseWindowMs(raw: string | undefined, defaultDays?: number): number;
+/** Build attributed-value trend counts for pull-based value:show (#1709). */
+export declare function computeValueShowTrend(projectRoot: string, options?: {
+    windowMs?: number;
+    logPath?: string | null;
+    now?: Date;
+}): ValueShowTrend;
+export declare function formatValueShowReport(trend: ValueShowTrend): string;
+/** Pull-based value:show CLI core (#1709). */
+export declare function runValueShow(options: {
+    projectRoot?: string | null;
+    window?: string;
+    format?: "text" | "json";
+    logPath?: string | null;
+    policyOverride?: ValueFeedbackResolved;
+}): ValueShowResult;
+export interface ValueShowCliArgs {
+    window?: string;
+    format?: "text" | "json";
+    projectRoot?: string;
+    error?: string;
+}
+export declare function parseValueShowArgs(argv: readonly string[]): ValueShowCliArgs;
+/** CLI entry for value:show (#1709). */
+export declare function valueShowMain(argv?: readonly string[]): number;
+/** CLI module entrypoint for dispatch (#1709). */
+export declare function mainEntry(argv?: string[]): number;
+//# sourceMappingURL=readback.d.ts.map

package/dist/value/readback.js

@@ -0,0 +1,503 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { runningInsideDeftRepo } from "../doctor/paths.js";
+import { ALL_ATTRIBUTION_EVENT_NAMES } from "../events/attribution-constants.js";
+import { DEFAULT_EVENT_LOG, readEvents } from "../lifecycle/events.js";
+import { isValueFeedbackPathAllowed, resolveValueFeedback, } from "../policy/value-feedback.js";
+import { resolveProjectRoot } from "../scope/project-context.js";
+import { MAX_LINE_CHARS } from "../triage/welcome/constants.js";
+import { probeAdoptionAtWorkBoundary } from "./adoption-emit.js";
+import { probeFrictionAtWorkBoundary } from "./friction-emit.js";
+/** Repeat-suppression window for the budgeted session readback (#1709 / #1279 parity). */
+export const VALUE_READBACK_SUPPRESSION_HOURS = 4;
+export const VALUE_READBACK_HISTORY_REL = join(".deft-cache", "value-readback-history.jsonl");
+export const VALUE_READBACK_HISTORY_SCHEMA = "deft.value.readback.v1";
+const ATTRIBUTION_NAME_SET = new Set(ALL_ATTRIBUTION_EVENT_NAMES);
+/** Signal-class priority: value/bypass beat adoption (#1709 RFC nudge ordering). */
+const SIGNAL_CLASS_PRIORITY = {
+    value: 0,
+    bypass: 1,
+    adoption: 2,
+    friction: 3,
+};
+function resolveLedgerPath(projectRoot, logPath) {
+    if (logPath !== undefined && logPath !== null) {
+        return resolve(logPath);
+    }
+    return resolve(projectRoot, DEFAULT_EVENT_LOG);
+}
+function parseDetectedAt(record) {
+    const raw = record.detected_at;
+    if (typeof raw !== "string" || raw.trim().length === 0) {
+        return null;
+    }
+    let text = raw.trim();
+    if (text.endsWith("Z")) {
+        text = `${text.slice(0, -1)}+00:00`;
+    }
+    const parsed = new Date(text);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+/** Read attribution ledger entries in emission order (#1709). */
+export function readAttributionEvents(options) {
+    try {
+        const logPath = resolveLedgerPath(options.projectRoot, options.logPath);
+        const since = options.since ?? null;
+        return readEvents(logPath).filter((record) => {
+            if (typeof record?.event !== "string" || !ATTRIBUTION_NAME_SET.has(record.event)) {
+                return false;
+            }
+            if (!isRecordPayload(record.payload)) {
+                return false;
+            }
+            if (since === null) {
+                return true;
+            }
+            const at = parseDetectedAt(record);
+            return at !== null && at.getTime() >= since.getTime();
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function signalClassOf(record) {
+    const payload = record.payload;
+    if (isRecordPayload(payload)) {
+        const raw = payload.signal_class;
+        if (raw === "value" || raw === "bypass" || raw === "adoption" || raw === "friction") {
+            return raw;
+        }
+    }
+    const prefix = record.event.split(":")[0];
+    if (prefix === "value" || prefix === "bypass" || prefix === "adoption" || prefix === "friction") {
+        return prefix;
+    }
+    return null;
+}
+function priorityOf(record) {
+    const cls = signalClassOf(record);
+    if (cls === null) {
+        return 99;
+    }
+    return SIGNAL_CLASS_PRIORITY[cls] ?? 99;
+}
+function truncate(text, maxChars) {
+    if (text.length <= maxChars) {
+        return text;
+    }
+    if (maxChars <= 3) {
+        return text.slice(0, maxChars);
+    }
+    return `${text.slice(0, maxChars - 3)}...`;
+}
+function payloadString(payload, key) {
+    const raw = payload[key];
+    if (typeof raw === "string" && raw.trim().length > 0) {
+        return raw.trim();
+    }
+    if (typeof raw === "number" && Number.isFinite(raw)) {
+        return String(raw);
+    }
+    return "";
+}
+/** Format one attributed session line from a concrete ledger event (#1709 attributed-only). */
+export function formatAttributedSessionLine(record) {
+    const cls = signalClassOf(record) ?? "value";
+    const payload = isRecordPayload(record.payload) ? record.payload : {};
+    const source = payloadString(payload, "source");
+    const detail = payloadString(payload, "detail");
+    const capability = payloadString(payload, "capability");
+    switch (record.event) {
+        case "value:gate-catch": {
+            const tail = detail.length > 0 ? `: ${detail}` : "";
+            return `[value] Gate catch (${source || "gate"})${tail}`;
+        }
+        case "value:wip-cap-protect": {
+            const count = payloadString(payload, "count");
+            const cap = payloadString(payload, "cap");
+            const pair = count && cap ? ` ${count}/${cap}` : "";
+            return `[value] WIP cap protected in-flight scope${pair}.`;
+        }
+        case "bypass:off-flow": {
+            const tail = detail.length > 0 ? `: ${detail}` : "";
+            return `[boundary] Off-flow signal (${source || "bypass"})${tail}`;
+        }
+        case "adoption:unused-capability": {
+            const tail = detail.length > 0 ? `: ${detail}` : capability;
+            return `[adoption] Unused capability${tail ? ` (${tail})` : ""}.`;
+        }
+        case "friction:directive-gap": {
+            const tail = detail.length > 0 ? `: ${detail}` : "";
+            return `[friction] Directive gap (${source || "friction"})${tail}`;
+        }
+        default:
+            return `[${cls}] ${record.event}`;
+    }
+}
+/** Pick the single highest-priority recent attribution for the session one-liner. */
+export function selectSessionAttribution(events) {
+    if (events.length === 0) {
+        return null;
+    }
+    const sorted = [...events].sort((a, b) => {
+        const pri = priorityOf(a) - priorityOf(b);
+        if (pri !== 0) {
+            return pri;
+        }
+        const aAt = parseDetectedAt(a)?.getTime() ?? 0;
+        const bAt = parseDetectedAt(b)?.getTime() ?? 0;
+        return bAt - aAt;
+    });
+    return sorted[0] ?? null;
+}
+function parseJsonObjectOrNull(text) {
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // malformed history line
+    }
+    return null;
+}
+function isRecordPayload(payload) {
+    return payload !== null && typeof payload === "object" && !Array.isArray(payload);
+}
+function historyPath(projectRoot) {
+    return resolve(projectRoot, VALUE_READBACK_HISTORY_REL);
+}
+function readLastHistoryRecord(path) {
+    if (!existsSync(path)) {
+        return null;
+    }
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+    const lines = text.split("\n").filter((line) => line.trim().length > 0);
+    if (lines.length === 0) {
+        return null;
+    }
+    const last = lines[lines.length - 1];
+    if (last === undefined) {
+        return null;
+    }
+    return parseJsonObjectOrNull(last);
+}
+function parseHistoryEmittedAt(record) {
+    const raw = record.emitted_at;
+    if (typeof raw !== "string" || raw.trim().length === 0) {
+        return null;
+    }
+    let candidate = raw.trim();
+    if (candidate.endsWith("Z")) {
+        candidate = `${candidate.slice(0, -1)}+00:00`;
+    }
+    const parsed = new Date(candidate);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+/** True when the same attribution event id was read back within the suppression window. */
+export function shouldSuppressSessionReadback(eventId, historyFile, options = {}) {
+    const prior = readLastHistoryRecord(historyFile);
+    if (prior === null) {
+        return false;
+    }
+    const emittedAt = parseHistoryEmittedAt(prior);
+    if (emittedAt === null) {
+        return false;
+    }
+    const now = options.now ?? new Date();
+    const ageMs = now.getTime() - emittedAt.getTime();
+    if (ageMs < 0 || ageMs >= VALUE_READBACK_SUPPRESSION_HOURS * 3_600_000) {
+        return false;
+    }
+    return prior.event_id === eventId;
+}
+function appendReadbackHistory(projectRoot, eventId, line, options = {}) {
+    const path = historyPath(projectRoot);
+    const record = {
+        schema: VALUE_READBACK_HISTORY_SCHEMA,
+        emitted_at: (options.now ?? new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+        event_id: eventId,
+        line,
+    };
+    try {
+        mkdirSync(join(path, ".."), { recursive: true });
+        appendFileSync(path, `${JSON.stringify(record)}\n`, "utf8");
+    }
+    catch {
+        // observability only
+    }
+}
+function maintainerReadbackDisabled(projectRoot) {
+    if (!runningInsideDeftRepo(projectRoot)) {
+        return false;
+    }
+    return process.env.DEFT_VALUE_SELF_DOGFOOD !== "1";
+}
+/** Budgeted session one-liner — silent when gated, empty, or debounced (#1709). */
+export function renderSessionReadback(projectRoot, options = {}) {
+    try {
+        const root = resolve(projectRoot);
+        if (maintainerReadbackDisabled(root)) {
+            return { line: null, suppressed: false, gated: true };
+        }
+        const policy = options.policyOverride ?? resolveValueFeedback(root);
+        if (isValueFeedbackPathAllowed("emitEvents", policy)) {
+            probeAdoptionAtWorkBoundary(root, {
+                logPath: options.logPath,
+                policyOverride: policy,
+            });
+            probeFrictionAtWorkBoundary(root, {
+                logPath: options.logPath,
+                policyOverride: policy,
+            });
+        }
+        if (!isValueFeedbackPathAllowed("sessionLine", policy)) {
+            return { line: null, suppressed: false, gated: true };
+        }
+        const events = readAttributionEvents({ projectRoot: root, logPath: options.logPath });
+        if (events.length === 0) {
+            return { line: null, suppressed: false, gated: false };
+        }
+        const selected = selectSessionAttribution(events);
+        if (selected === null) {
+            return { line: null, suppressed: false, gated: false };
+        }
+        const hist = historyPath(root);
+        if (shouldSuppressSessionReadback(selected.id, hist, { now: options.now })) {
+            return { line: null, suppressed: true, gated: false };
+        }
+        const maxChars = options.maxChars ?? MAX_LINE_CHARS;
+        const line = truncate(formatAttributedSessionLine(selected), maxChars);
+        if (options.writeHistory !== false) {
+            appendReadbackHistory(root, selected.id, line, { now: options.now });
+        }
+        return { line, suppressed: false, gated: false };
+    }
+    catch {
+        return { line: null, suppressed: false, gated: false };
+    }
+}
+/** Emit the session readback line to stdout when present. Returns the line or null. */
+export function emitSessionValueReadback(projectRoot, options = {}) {
+    const result = renderSessionReadback(projectRoot, options);
+    if (result.line === null) {
+        return null;
+    }
+    const out = options.output ?? ((line) => process.stdout.write(`${line}\n`));
+    out(result.line);
+    return result.line;
+}
+export function parseWindowMs(raw, defaultDays = 7) {
+    if (raw === undefined || raw.trim().length === 0) {
+        return defaultDays * 86_400_000;
+    }
+    const match = /^(\d+)([dhm])$/i.exec(raw.trim());
+    if (match === null) {
+        return defaultDays * 86_400_000;
+    }
+    const amount = Number.parseInt(match[1] ?? "", 10);
+    if (!Number.isFinite(amount) || amount <= 0) {
+        return defaultDays * 86_400_000;
+    }
+    const unit = (match[2] ?? "d").toLowerCase();
+    if (unit === "h") {
+        return amount * 3_600_000;
+    }
+    if (unit === "m") {
+        return amount * 60_000;
+    }
+    return amount * 86_400_000;
+}
+function formatWindowLabel(windowMs) {
+    const days = Math.round(windowMs / 86_400_000);
+    if (days >= 1 && days * 86_400_000 === windowMs) {
+        return `${days}d`;
+    }
+    const hours = Math.round(windowMs / 3_600_000);
+    if (hours >= 1 && hours * 3_600_000 === windowMs) {
+        return `${hours}h`;
+    }
+    return `${windowMs}ms`;
+}
+/** Build attributed-value trend counts for pull-based value:show (#1709). */
+export function computeValueShowTrend(projectRoot, options = {}) {
+    const windowMs = options.windowMs ?? 7 * 86_400_000;
+    const now = options.now ?? new Date();
+    const since = new Date(now.getTime() - windowMs);
+    const events = readAttributionEvents({
+        projectRoot,
+        logPath: options.logPath,
+        since,
+    });
+    const byClass = {
+        value: 0,
+        bypass: 0,
+        adoption: 0,
+        friction: 0,
+    };
+    const byEvent = {};
+    for (const record of events) {
+        const cls = signalClassOf(record);
+        if (cls !== null) {
+            byClass[cls] += 1;
+        }
+        byEvent[record.event] = (byEvent[record.event] ?? 0) + 1;
+    }
+    return {
+        windowLabel: formatWindowLabel(windowMs),
+        windowMs,
+        total: events.length,
+        byClass,
+        byEvent,
+        recent: events.slice(-5),
+    };
+}
+export function formatValueShowReport(trend) {
+    if (trend.total === 0) {
+        return (`[value] No attributed signals in the last ${trend.windowLabel} ` +
+            "(ledger empty for this window).\n" +
+            "Inspect policy: `task policy:show --field=valueFeedback`.\n");
+    }
+    const classParts = ["value", "bypass", "adoption", "friction"]
+        .filter((key) => trend.byClass[key] > 0)
+        .map((key) => `${key}=${trend.byClass[key]}`);
+    const eventParts = Object.entries(trend.byEvent)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([name, count]) => `${name}: ${count}`);
+    const lines = [
+        `[value] Attributed signals (${trend.windowLabel}): ${trend.total} total`,
+        `  classes: ${classParts.join(", ")}`,
+        `  events: ${eventParts.join("; ")}`,
+        "Pull detail any time with `task value:show -- --window=30d --format=json`.",
+    ];
+    return `${lines.join("\n")}\n`;
+}
+/** Pull-based value:show CLI core (#1709). */
+export function runValueShow(options) {
+    const rootRaw = resolveProjectRoot(options.projectRoot ?? undefined);
+    if (rootRaw === null) {
+        return {
+            exitCode: 2,
+            gated: false,
+            empty: true,
+            text: "Error: could not resolve project root.\n",
+            trend: null,
+        };
+    }
+    const root = resolve(rootRaw);
+    if (maintainerReadbackDisabled(root)) {
+        return {
+            exitCode: 0,
+            gated: true,
+            empty: true,
+            text: "[value] Skipped: maintainer framework repo (set DEFT_VALUE_SELF_DOGFOOD=1 to dogfood).\n",
+            trend: null,
+        };
+    }
+    const policy = options.policyOverride ?? resolveValueFeedback(root);
+    if (!policy.enabled) {
+        return {
+            exitCode: 1,
+            gated: true,
+            empty: true,
+            text: "[value] Blocked: plan.policy.valueFeedback is OFF. " +
+                "Enable with `task policy:enable-value-feedback -- --confirm`.\n",
+            trend: null,
+        };
+    }
+    const windowMs = parseWindowMs(options.window);
+    const trend = computeValueShowTrend(root, { windowMs, logPath: options.logPath });
+    const empty = trend.total === 0;
+    if (options.format === "json") {
+        return {
+            exitCode: 0,
+            gated: false,
+            empty,
+            text: `${JSON.stringify(trend, null, 2)}\n`,
+            trend,
+        };
+    }
+    return {
+        exitCode: 0,
+        gated: false,
+        empty,
+        text: formatValueShowReport(trend),
+        trend,
+    };
+}
+export function parseValueShowArgs(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--format") {
+            const raw = argv[++i];
+            if (raw === "json" || raw === "text") {
+                out.format = raw;
+            }
+            else {
+                return { ...out, error: `--format expects text|json, got ${JSON.stringify(raw)}` };
+            }
+        }
+        else if (arg?.startsWith("--format=")) {
+            const raw = arg.slice("--format=".length);
+            if (raw === "json" || raw === "text") {
+                out.format = raw;
+            }
+            else {
+                return { ...out, error: `--format expects text|json, got ${JSON.stringify(raw)}` };
+            }
+        }
+        else if (arg === "--window") {
+            const raw = argv[++i];
+            if (raw === undefined) {
+                return { ...out, error: "--window requires a value (e.g. --window=7d)" };
+            }
+            out.window = raw;
+        }
+        else if (arg?.startsWith("--window=")) {
+            out.window = arg.slice("--window=".length);
+        }
+        else if (arg === "--project-root") {
+            const raw = argv[++i];
+            if (raw === undefined) {
+                return { ...out, error: "--project-root requires a path" };
+            }
+            out.projectRoot = raw;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            out.projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg.startsWith("-")) {
+            return { ...out, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return out;
+}
+/** CLI entry for value:show (#1709). */
+export function valueShowMain(argv = process.argv.slice(2)) {
+    const args = parseValueShowArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`value:show: ${args.error}\n`);
+        return 2;
+    }
+    const result = runValueShow({
+        projectRoot: args.projectRoot,
+        window: args.window,
+        format: args.format ?? "text",
+    });
+    process.stdout.write(result.text);
+    return result.exitCode;
+}
+/** CLI module entrypoint for dispatch (#1709). */
+export function mainEntry(argv = process.argv.slice(2)) {
+    return valueShowMain(argv);
+}
+//# sourceMappingURL=readback.js.map

package/dist/vbrief-validate/decomposition.js

@@ -30,7 +30,7 @@ export function validateNoRootDecompositionDrafts(vbriefDir) {
         }
         if (looksLikeDecompositionDraft(data)) {
             errors.push(`${path}: decomposition draft JSON must not live at workspace root; ` +
-                "write temporary proposals under vbrief/.eval/decompositions/");
+                "write temporary proposals under vbrief/.triage-cache/decompositions/");
         }
     }
     return errors;

package/dist/wip-cap/evaluate.js

@@ -1,4 +1,5 @@
 import { resolve } from "node:path";
+import { recordBypassSignal, recordWipCapProtect } from "../events/attribution-ledger.js";
 import { countVbriefWip, resolveWipCap } from "../policy/wip.js";
 function formatRefusal(count, cap, projectRoot) {
     return (`❌ verify:wip-cap: ${count}/${cap} in pending/+active/ ` +
@@ -40,6 +41,7 @@ export function evaluate(projectRoot, options = {}) {
         };
     }
     if (allowOverCap) {
+        recordBypassSignal(root, "verify:wip-cap", `--allow-over-cap passed (${count}/${cap} in pending/+active/)`);
         if (quiet) {
             return { code: 0, message: "", stream: "none" };
         }
@@ -53,6 +55,7 @@ export function evaluate(projectRoot, options = {}) {
             stream: "stderr",
         };
     }
+    recordWipCapProtect(root, count, cap);
     return {
         code: 1,
         message: formatRefusal(count, cap, root),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.70.0",
+  "version": "0.71.1",
   "description": "TypeScript engine core for the Directive framework.",
   "type": "module",
   "main": "./dist/index.js",
@@ -70,6 +70,38 @@
       "types": "./dist/doctor/index.d.ts",
       "default": "./dist/doctor/index.js"
     },
+    "./eval": {
+      "types": "./dist/eval/health.d.ts",
+      "default": "./dist/eval/health.js"
+    },
+    "./eval/health": {
+      "types": "./dist/eval/health.d.ts",
+      "default": "./dist/eval/health.js"
+    },
+    "./eval/crud-telemetry": {
+      "types": "./dist/eval/crud-telemetry.d.ts",
+      "default": "./dist/eval/crud-telemetry.js"
+    },
+    "./value/feedback-file": {
+      "types": "./dist/value/feedback-file.d.ts",
+      "default": "./dist/value/feedback-file.js"
+    },
+    "./value/readback": {
+      "types": "./dist/value/readback.d.ts",
+      "default": "./dist/value/readback.js"
+    },
+    "./events": {
+      "types": "./dist/events/attribution-ledger.d.ts",
+      "default": "./dist/events/attribution-ledger.js"
+    },
+    "./eval/run": {
+      "types": "./dist/eval/run.d.ts",
+      "default": "./dist/eval/run.js"
+    },
+    "./eval/report": {
+      "types": "./dist/eval/report.d.ts",
+      "default": "./dist/eval/report.js"
+    },
     "./triage": {
       "types": "./dist/triage/index.d.ts",
       "default": "./dist/triage/index.js"
@@ -249,8 +281,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-content": "^0.70.0",
-    "@deftai/directive-types": "^0.70.0",
+    "@deftai/directive-content": "^0.71.1",
+    "@deftai/directive-types": "^0.71.1",
     "archiver": "^8.0.0"
   },
   "scripts": {