@deftai/directive-core 0.70.0 → 0.71.0

package/dist/events/attribution-ledger.js

@@ -0,0 +1,61 @@
+import { resolve } from "node:path";
+import { DEFAULT_EVENT_LOG, emit } from "../lifecycle/events.js";
+import { isValueFeedbackPathAllowed, resolveValueFeedback, } from "../policy/value-feedback.js";
+import { ATTRIBUTION_EVENT_NAMES } from "./attribution-constants.js";
+export { ALL_ATTRIBUTION_EVENT_NAMES, ATTRIBUTION_EVENT_NAMES, ATTRIBUTION_REQUIRED_PAYLOAD, } from "./attribution-constants.js";
+function resolveLedgerLogPath(projectRoot, logPath) {
+    if (logPath !== undefined && logPath !== null) {
+        return resolve(logPath);
+    }
+    return resolve(projectRoot, DEFAULT_EVENT_LOG);
+}
+function signalClassForEvent(name) {
+    const prefix = name.split(":")[0];
+    if (prefix === "value" || prefix === "bypass" || prefix === "adoption" || prefix === "friction") {
+        return prefix;
+    }
+    throw new Error(`attribution event '${name}' has unknown signal-class prefix`);
+}
+/**
+ * Append an attribution ledger entry when valueFeedback emitEvents is allowed.
+ * Returns null when gated OFF (no disk write).
+ */
+export function emitAttributionSignal(name, payload, options) {
+    try {
+        const policy = options.policyOverride ?? resolveValueFeedback(options.projectRoot);
+        if (!isValueFeedbackPathAllowed("emitEvents", policy)) {
+            return null;
+        }
+        const signalClass = signalClassForEvent(name);
+        const logPath = resolveLedgerLogPath(options.projectRoot, options.logPath);
+        return emit(name, {
+            signal_class: signalClass,
+            ...payload,
+        }, { logPath });
+    }
+    catch {
+        // Telemetry is best-effort; any failure must not interrupt gate callers (#1709).
+        return null;
+    }
+}
+/** Record a detection-bound gate catch (value class). */
+export function recordGateCatch(projectRoot, source, detail, options = {}) {
+    return emitAttributionSignal(ATTRIBUTION_EVENT_NAMES.valueGateCatch, { source, detail }, { projectRoot, ...options });
+}
+/** Record a WIP-cap protect refusal (value class). */
+export function recordWipCapProtect(projectRoot, count, cap, options = {}) {
+    return emitAttributionSignal(ATTRIBUTION_EVENT_NAMES.valueWipCapProtect, { source: "verify:wip-cap", count, cap }, { projectRoot, ...options });
+}
+/** Record a bypass/off-flow signal. */
+export function recordBypassSignal(projectRoot, source, detail, options = {}) {
+    return emitAttributionSignal(ATTRIBUTION_EVENT_NAMES.bypassOffFlow, { source, detail }, { projectRoot, ...options });
+}
+/** Record an adoption/unused-capability signal. */
+export function recordAdoptionSignal(projectRoot, capability, detail, options = {}) {
+    return emitAttributionSignal(ATTRIBUTION_EVENT_NAMES.adoptionUnusedCapability, { source: "adoption-registry", capability, detail }, { projectRoot, ...options });
+}
+/** Record a friction/directive-gap signal. */
+export function recordFrictionSignal(projectRoot, source, detail, options = {}) {
+    return emitAttributionSignal(ATTRIBUTION_EVENT_NAMES.frictionDirectiveGap, { source, detail }, { projectRoot, ...options });
+}
+//# sourceMappingURL=attribution-ledger.js.map

package/dist/index.d.ts

@@ -15,6 +15,11 @@ export * as capacity from "./capacity/index.js";
 export * as codebase from "./codebase/index.js";
 export * as doctor from "./doctor/index.js";
 export * from "./encoding/index.js";
+export * as evalCrud from "./eval/crud-telemetry.js";
+export * as evalHealth from "./eval/health.js";
+export * as evalReport from "./eval/report.js";
+export * as evalRun from "./eval/run.js";
+export * as events from "./events/attribution-ledger.js";
 export * from "./forward-coverage/evaluate.js";
 export * as intake from "./intake/index.js";
 export * as layout from "./layout/index.js";

package/dist/index.js

@@ -15,6 +15,11 @@ export * as capacity from "./capacity/index.js";
 export * as codebase from "./codebase/index.js";
 export * as doctor from "./doctor/index.js";
 export * from "./encoding/index.js";
+export * as evalCrud from "./eval/crud-telemetry.js";
+export * as evalHealth from "./eval/health.js";
+export * as evalReport from "./eval/report.js";
+export * as evalRun from "./eval/run.js";
+export * as events from "./events/attribution-ledger.js";
 export * from "./forward-coverage/evaluate.js";
 export * as intake from "./intake/index.js";
 export * as layout from "./layout/index.js";

package/dist/init-deposit/gitignore.js

@@ -26,11 +26,11 @@ export const CANONICAL_GITIGNORE_BASELINE = [
     ".deft/ritual-state.json",
     ".deft/last-session.json",
     ".deft/routing.local.json",
-    "vbrief/.eval/candidates.jsonl",
-    "vbrief/.eval/summary-history.jsonl",
-    "vbrief/.eval/scope-lifecycle.jsonl",
-    "vbrief/.eval/decompositions/",
-    "vbrief/.eval/doctor-state.json",
+    "vbrief/.triage-cache/candidates.jsonl",
+    "vbrief/.triage-cache/summary-history.jsonl",
+    "vbrief/.triage-cache/scope-lifecycle.jsonl",
+    "vbrief/.triage-cache/decompositions/",
+    "vbrief/.triage-cache/doctor-state.json",
     "vbrief/*.lock",
     ".deft/core.bak-*/",
     ".deft/*.bak-*",

package/dist/layout/resolve.d.ts

@@ -51,9 +51,9 @@ export declare function resolveLifecycleRoot(projectRoot: string): string;
  * (e.g. `<root>/<xbrief|vbrief>/active`). Layout-aware (#2109 part 2a).
  */
 export declare function resolveLifecycleFolder(projectRoot: string, folder: string): string;
-/** Absolute path to the resolved lifecycle `.eval` cache directory (#2109 part 2a). */
+/** Absolute path to the layout-aware `.eval/` directory for version-eval results (#1703). */
 export declare function resolveEvalDir(projectRoot: string): string;
-/** Absolute path to a file or subpath under the resolved `.eval` cache directory. */
+/** Absolute path under `.eval/` for version-eval artefacts (not triage working-set). */
 export declare function resolveEvalPath(projectRoot: string, ...segments: string[]): string;
 /** Absolute path to the resolved lifecycle `.audit` directory (#2109 part 2a). */
 export declare function resolveAuditDir(projectRoot: string): string;

package/dist/layout/resolve.js

@@ -101,11 +101,11 @@ export function resolveLifecycleRoot(projectRoot) {
 export function resolveLifecycleFolder(projectRoot, folder) {
     return join(resolveLifecycleRoot(projectRoot), folder);
 }
-/** Absolute path to the resolved lifecycle `.eval` cache directory (#2109 part 2a). */
+/** Absolute path to the layout-aware `.eval/` directory for version-eval results (#1703). */
 export function resolveEvalDir(projectRoot) {
     return join(resolveLifecycleRoot(projectRoot), ".eval");
 }
-/** Absolute path to a file or subpath under the resolved `.eval` cache directory. */
+/** Absolute path under `.eval/` for version-eval artefacts (not triage working-set). */
 export function resolveEvalPath(projectRoot, ...segments) {
     return join(resolveEvalDir(projectRoot), ...segments);
 }

package/dist/lifecycle/events.js

@@ -3,10 +3,12 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { contentRoot } from "../content-root.js";
+import { ATTRIBUTION_REQUIRED_PAYLOAD } from "../events/attribution-constants.js";
 /** Default event log location (project-local). */
 export const DEFAULT_EVENT_LOG = join(".deft-cache", "events.jsonl");
 const BEHAVIORAL_CATEGORY = "behavioral";
 const REQUIRED_BEHAVIORAL_PAYLOAD = {
+    ...ATTRIBUTION_REQUIRED_PAYLOAD,
     "session:interrupted": ["session_id", "reason"],
     "session:resumed": ["session_id", "interrupted_id"],
     "plan:approved": ["plan_ref", "approver"],

package/dist/policy/index.d.ts

@@ -5,6 +5,7 @@ export * from "./decisions.js";
 export * from "./disclosure.js";
 export * from "./plan-extensions.js";
 export * from "./resolve.js";
+export * from "./value-feedback.js";
 export * from "./wip.js";
 export declare const FIELD_ALLOW_DIRECT_COMMITS = "plan.policy.allowDirectCommitsToMaster";
 export declare const FIELD_WIP_CAP = "plan.policy.wipCap";
@@ -29,7 +30,7 @@ export interface PolicyField {
 }
 /** Walk registered inspectors and return one row per field (#1148). */
 export declare function inspectAllPolicies(projectRoot: string): PolicyField[];
-/** Look up a single registered field by canonical dotted-path name. */
+/** Look up a single registered field by canonical dotted-path name (or CLI alias). */
 export declare function inspectOnePolicy(name: string, projectRoot: string): PolicyField | null;
 /** Return canonical names of every registered typed-policy field. */
 export declare function registeredPolicyNames(): string[];

package/dist/policy/index.js

@@ -1,5 +1,6 @@
 import { readPlanPolicy } from "./plan-extensions.js";
 import { coerceLegacyNarrative, LEGACY_NARRATIVE_KEY, loadProjectDefinition } from "./resolve.js";
+import { FIELD_VALUE_FEEDBACK, FIELD_VALUE_FEEDBACK_CLI_ALIAS, inspectValueFeedback, } from "./value-feedback.js";
 import { DEFAULT_WIP_CAP } from "./wip.js";
 export * from "./agents-md-advisory.js";
 export * from "./autonomy.js";
@@ -8,6 +9,7 @@ export * from "./decisions.js";
 export * from "./disclosure.js";
 export * from "./plan-extensions.js";
 export * from "./resolve.js";
+export * from "./value-feedback.js";
 export * from "./wip.js";
 export const FIELD_ALLOW_DIRECT_COMMITS = "plan.policy.allowDirectCommitsToMaster";
 export const FIELD_WIP_CAP = "plan.policy.wipCap";
@@ -213,6 +215,15 @@ function inspectSwarmSubagentBackend(data) {
         source: "default-on-error",
     };
 }
+function inspectValueFeedbackField(data) {
+    const field = inspectValueFeedback(data);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 const REGISTERED_POLICIES = [
     inspectAllowDirectCommits,
     inspectWipCap,
@@ -225,16 +236,18 @@ const REGISTERED_POLICIES = [
         emptyIsTyped: true,
     }),
     inspectSwarmSubagentBackend,
+    inspectValueFeedbackField,
 ];
 /** Walk registered inspectors and return one row per field (#1148). */
 export function inspectAllPolicies(projectRoot) {
     const [data] = loadProjectDefinition(projectRoot);
     return REGISTERED_POLICIES.map((inspect) => inspect(data));
 }
-/** Look up a single registered field by canonical dotted-path name. */
+/** Look up a single registered field by canonical dotted-path name (or CLI alias). */
 export function inspectOnePolicy(name, projectRoot) {
+    const normalized = name === FIELD_VALUE_FEEDBACK_CLI_ALIAS ? FIELD_VALUE_FEEDBACK : name;
     for (const field of inspectAllPolicies(projectRoot)) {
-        if (field.name === name)
+        if (field.name === normalized)
             return field;
     }
     return null;

package/dist/policy/value-feedback.d.ts

@@ -0,0 +1,56 @@
+/** Canonical registered policy field name (matches other FIELD_* dotted paths). */
+export declare const FIELD_VALUE_FEEDBACK = "plan.policy.valueFeedback";
+/** Short alias accepted by `policy:show --field=valueFeedback` (#1709). */
+export declare const FIELD_VALUE_FEEDBACK_CLI_ALIAS = "valueFeedback";
+export declare const DEFAULT_VALUE_FEEDBACK_ENABLED = false;
+/** Sub-flag defaults applied when the master flag is enabled (#1709 tiered-cost decision). */
+export declare const VALUE_FEEDBACK_SUBFLAG_DEFAULTS_WHEN_ENABLED: {
+    readonly emitEvents: true;
+    readonly sessionLine: true;
+    readonly upstreamPrompt: false;
+};
+export type ValueFeedbackSubFlag = keyof typeof VALUE_FEEDBACK_SUBFLAG_DEFAULTS_WHEN_ENABLED;
+export interface ValueFeedbackConfig {
+    readonly enabled: boolean;
+    readonly emitEvents: boolean;
+    readonly sessionLine: boolean;
+    readonly upstreamPrompt: boolean;
+}
+export type ValueFeedbackSource = "typed" | "default" | "default-on-error";
+export interface ValueFeedbackResolved extends ValueFeedbackConfig {
+    readonly source: ValueFeedbackSource;
+    readonly error: string | null;
+}
+export declare const VALUE_FEEDBACK_CAPABILITY_COST_DISCLOSURE: string;
+/** Validate a `plan.policy.valueFeedback` payload. */
+export declare function validateValueFeedback(value: unknown): string[];
+/** Resolve `plan.policy.valueFeedback` from PROJECT-DEFINITION (#1709). */
+export declare function resolveValueFeedback(projectRoot: string): ValueFeedbackResolved;
+/** Master gate: when `enabled` is false, every downstream path is rejected. */
+export declare function isValueFeedbackPathAllowed(path: ValueFeedbackSubFlag, policy: ValueFeedbackResolved): boolean;
+/** Resolved per-path gate booleans for policy:show and enable status output. */
+export declare function valueFeedbackPathGates(policy: ValueFeedbackResolved): Record<ValueFeedbackSubFlag, boolean>;
+/** Human-readable status line for CLI enable/show surfaces. */
+export declare function formatValueFeedbackStatusLine(policy: ValueFeedbackResolved): string;
+export interface ValueFeedbackPolicyField {
+    readonly name: typeof FIELD_VALUE_FEEDBACK;
+    readonly current: ValueFeedbackConfig;
+    readonly default: ValueFeedbackConfig;
+    readonly source: string;
+}
+/** Inspector row for `policy:show --field=valueFeedback`. */
+export declare function inspectValueFeedback(data: Record<string, unknown> | null): ValueFeedbackPolicyField;
+export interface EnableValueFeedbackOptions {
+    readonly confirm: boolean;
+    readonly actor?: string;
+    readonly note?: string;
+    readonly subFlags?: Partial<Record<ValueFeedbackSubFlag, boolean>>;
+}
+export interface EnableValueFeedbackResult {
+    readonly exitCode: 0 | 1 | 2;
+    readonly stdout: string;
+    readonly changed: boolean;
+}
+/** Persist `valueFeedback.enabled=true` after capability-cost disclosure (#1709). */
+export declare function enableValueFeedback(projectRoot: string, options: EnableValueFeedbackOptions): EnableValueFeedbackResult;
+//# sourceMappingURL=value-feedback.d.ts.map

package/dist/policy/value-feedback.js

@@ -0,0 +1,284 @@
+import { readFileSync } from "node:fs";
+import { atomicWriteProjectDefinition, projectDefinitionMutationLock, } from "../vbrief-build/project-definition-io.js";
+import { migrateLegacyPolicyKey, PLAN_POLICY_KEY, readPlanPolicy } from "./plan-extensions.js";
+import { appendAuditLog, loadProjectDefinition, projectDefinitionPath } from "./resolve.js";
+/** Canonical registered policy field name (matches other FIELD_* dotted paths). */
+export const FIELD_VALUE_FEEDBACK = "plan.policy.valueFeedback";
+/** Short alias accepted by `policy:show --field=valueFeedback` (#1709). */
+export const FIELD_VALUE_FEEDBACK_CLI_ALIAS = "valueFeedback";
+export const DEFAULT_VALUE_FEEDBACK_ENABLED = false;
+/** Sub-flag defaults applied when the master flag is enabled (#1709 tiered-cost decision). */
+export const VALUE_FEEDBACK_SUBFLAG_DEFAULTS_WHEN_ENABLED = {
+    emitEvents: true,
+    sessionLine: true,
+    upstreamPrompt: false,
+};
+export const VALUE_FEEDBACK_CAPABILITY_COST_DISCLOSURE = "\u26a0 Capability-cost disclosure -- enabling value feedback opts into " +
+    "attributed awareness surfaces that may consume session context and nudge budget.\n" +
+    "  \u2022 Local emit-only ledger writes to the gitignored `.deft-cache/events.jsonl` " +
+    "(no network by default).\n" +
+    "  \u2022 A budgeted session one-liner may appear when concrete attributed value exists.\n" +
+    "  \u2022 Upstream gap-escalation prompts stay OFF unless you explicitly enable " +
+    "`upstreamPrompt` (GitHub attention + token cost).\n" +
+    "  \u2022 Inspect current state: `task policy:show --field=valueFeedback`.\n" +
+    "  \u2022 Reversible: set `enabled: false` under the typed policy block in PROJECT-DEFINITION.\n" +
+    "  \u2022 Changes are recorded to meta/policy-changes.log for auditability.";
+function defaultResolved(source, error = null) {
+    return {
+        enabled: DEFAULT_VALUE_FEEDBACK_ENABLED,
+        emitEvents: false,
+        sessionLine: false,
+        upstreamPrompt: false,
+        source,
+        error,
+    };
+}
+function readSubFlag(block, key, masterEnabled) {
+    if (!masterEnabled) {
+        return false;
+    }
+    if (key in block && typeof block[key] === "boolean") {
+        return block[key];
+    }
+    return VALUE_FEEDBACK_SUBFLAG_DEFAULTS_WHEN_ENABLED[key];
+}
+/** Validate a `plan.policy.valueFeedback` payload. */
+export function validateValueFeedback(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        return [`${FIELD_VALUE_FEEDBACK} must be an object; got ${typeof value}`];
+    }
+    const rec = value;
+    const errors = [];
+    for (const key of ["enabled", "emitEvents", "sessionLine", "upstreamPrompt"]) {
+        if (key in rec && typeof rec[key] !== "boolean") {
+            errors.push(`${FIELD_VALUE_FEEDBACK}.${key} must be a boolean`);
+        }
+    }
+    return errors;
+}
+function resolveFromPolicyBlock(raw) {
+    const errors = validateValueFeedback(raw);
+    if (errors.length > 0) {
+        return defaultResolved("default-on-error", errors[0] ?? "invalid valueFeedback block");
+    }
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return defaultResolved("default");
+    }
+    const block = raw;
+    const enabled = typeof block.enabled === "boolean" ? block.enabled : DEFAULT_VALUE_FEEDBACK_ENABLED;
+    if (!enabled) {
+        return {
+            enabled: false,
+            emitEvents: false,
+            sessionLine: false,
+            upstreamPrompt: false,
+            source: "typed",
+            error: null,
+        };
+    }
+    return {
+        enabled: true,
+        emitEvents: readSubFlag(block, "emitEvents", true),
+        sessionLine: readSubFlag(block, "sessionLine", true),
+        upstreamPrompt: readSubFlag(block, "upstreamPrompt", true),
+        source: "typed",
+        error: null,
+    };
+}
+/** Resolve `plan.policy.valueFeedback` from PROJECT-DEFINITION (#1709). */
+export function resolveValueFeedback(projectRoot) {
+    const [data, err] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return defaultResolved("default-on-error", err);
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("valueFeedback" in policyBlock)) {
+        return defaultResolved("default");
+    }
+    return resolveFromPolicyBlock(policyBlock.valueFeedback);
+}
+/** Master gate: when `enabled` is false, every downstream path is rejected. */
+export function isValueFeedbackPathAllowed(path, policy) {
+    if (!policy.enabled) {
+        return false;
+    }
+    return policy[path];
+}
+/** Resolved per-path gate booleans for policy:show and enable status output. */
+export function valueFeedbackPathGates(policy) {
+    return {
+        emitEvents: isValueFeedbackPathAllowed("emitEvents", policy),
+        sessionLine: isValueFeedbackPathAllowed("sessionLine", policy),
+        upstreamPrompt: isValueFeedbackPathAllowed("upstreamPrompt", policy),
+    };
+}
+/** Human-readable status line for CLI enable/show surfaces. */
+export function formatValueFeedbackStatusLine(policy) {
+    const gates = valueFeedbackPathGates(policy);
+    return (`[deft policy] valueFeedback enabled=${String(policy.enabled)} ` +
+        `emitEvents=${String(policy.emitEvents)} (path=${String(gates.emitEvents)}) ` +
+        `sessionLine=${String(policy.sessionLine)} (path=${String(gates.sessionLine)}) ` +
+        `upstreamPrompt=${String(policy.upstreamPrompt)} (path=${String(gates.upstreamPrompt)}).`);
+}
+function defaultInspectorConfig() {
+    const defaults = defaultResolved("default");
+    return {
+        enabled: defaults.enabled,
+        emitEvents: defaults.emitEvents,
+        sessionLine: defaults.sessionLine,
+        upstreamPrompt: defaults.upstreamPrompt,
+    };
+}
+function buildDefaultInspectorField() {
+    return {
+        name: FIELD_VALUE_FEEDBACK,
+        current: defaultInspectorConfig(),
+        default: {
+            enabled: DEFAULT_VALUE_FEEDBACK_ENABLED,
+            emitEvents: false,
+            sessionLine: false,
+            upstreamPrompt: false,
+        },
+        source: "default",
+    };
+}
+/** Inspector row for `policy:show --field=valueFeedback`. */
+export function inspectValueFeedback(data) {
+    if (data === null) {
+        return buildDefaultInspectorField();
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("valueFeedback" in policyBlock)) {
+        return buildDefaultInspectorField();
+    }
+    const resolved = resolveFromPolicyBlock(policyBlock.valueFeedback);
+    return {
+        name: FIELD_VALUE_FEEDBACK,
+        current: {
+            enabled: resolved.enabled,
+            emitEvents: resolved.emitEvents,
+            sessionLine: resolved.sessionLine,
+            upstreamPrompt: resolved.upstreamPrompt,
+        },
+        default: {
+            enabled: DEFAULT_VALUE_FEEDBACK_ENABLED,
+            emitEvents: false,
+            sessionLine: false,
+            upstreamPrompt: false,
+        },
+        source: resolved.source,
+    };
+}
+/** Persist `valueFeedback.enabled=true` after capability-cost disclosure (#1709). */
+export function enableValueFeedback(projectRoot, options) {
+    if (!options.confirm) {
+        return {
+            exitCode: 1,
+            stdout: `${VALUE_FEEDBACK_CAPABILITY_COST_DISCLOSURE}\n\n` +
+                "Re-run with --confirm to apply: task policy:enable-value-feedback -- --confirm\n",
+            changed: false,
+        };
+    }
+    const path = projectDefinitionPath(projectRoot);
+    try {
+        const { changed } = projectDefinitionMutationLock(projectRoot, () => {
+            const parsed = JSON.parse(readFileSync(path, { encoding: "utf8" }));
+            if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+                throw new Error(`PROJECT-DEFINITION at ${path} top-level value is not a JSON object`);
+            }
+            const data = parsed;
+            if (typeof data.plan !== "object" || data.plan === null || Array.isArray(data.plan)) {
+                if (data.plan === undefined) {
+                    data.plan = {};
+                }
+                else {
+                    throw new Error("PROJECT-DEFINITION 'plan' is not an object");
+                }
+            }
+            const plan = data.plan;
+            migrateLegacyPolicyKey(plan);
+            const existingPolicy = plan[PLAN_POLICY_KEY];
+            if (typeof existingPolicy !== "object" ||
+                existingPolicy === null ||
+                Array.isArray(existingPolicy)) {
+                if (existingPolicy === undefined) {
+                    plan[PLAN_POLICY_KEY] = {};
+                }
+                else {
+                    throw new Error("plan.policy is not an object");
+                }
+            }
+            const policyBlock = plan[PLAN_POLICY_KEY];
+            const previous = policyBlock.valueFeedback;
+            const prevObj = typeof previous === "object" && previous !== null && !Array.isArray(previous)
+                ? previous
+                : {};
+            const sub = options.subFlags ?? {};
+            const readPersistedSubFlag = (key) => {
+                if (key in sub && typeof sub[key] === "boolean") {
+                    return sub[key];
+                }
+                if (key in prevObj && typeof prevObj[key] === "boolean") {
+                    return prevObj[key];
+                }
+                return VALUE_FEEDBACK_SUBFLAG_DEFAULTS_WHEN_ENABLED[key];
+            };
+            const nextBlock = {
+                enabled: true,
+                emitEvents: readPersistedSubFlag("emitEvents"),
+                sessionLine: readPersistedSubFlag("sessionLine"),
+                upstreamPrompt: readPersistedSubFlag("upstreamPrompt"),
+            };
+            const previousNormalized = resolveFromPolicyBlock(previous);
+            const changedFlag = previousNormalized.enabled !== nextBlock.enabled ||
+                previousNormalized.emitEvents !== nextBlock.emitEvents ||
+                previousNormalized.sessionLine !== nextBlock.sessionLine ||
+                previousNormalized.upstreamPrompt !== nextBlock.upstreamPrompt;
+            policyBlock.valueFeedback = nextBlock;
+            if (changedFlag) {
+                atomicWriteProjectDefinition(path, data);
+            }
+            const actor = options.actor ?? "task policy:enable-value-feedback";
+            const note = options.note ?? "";
+            const parts = [
+                `actor=${actor}`,
+                "valueFeedback.enabled=true",
+                `emitEvents=${String(nextBlock.emitEvents)}`,
+                `sessionLine=${String(nextBlock.sessionLine)}`,
+                `upstreamPrompt=${String(nextBlock.upstreamPrompt)}`,
+                `previous=${JSON.stringify(previous ?? null)}`,
+            ];
+            if (note) {
+                parts.push(`note=${note.replace(/\n/g, " ").replace(/\r/g, " ")}`);
+            }
+            appendAuditLog(projectRoot, parts.join(" "));
+            return { changed: changedFlag };
+        });
+        const resolved = resolveValueFeedback(projectRoot);
+        const lines = [
+            `\u2713 ${FIELD_VALUE_FEEDBACK}.enabled=true (value-feedback ON).`,
+            changed
+                ? "  audit: meta/policy-changes.log updated."
+                : "  no-op: value already matched (audit entry still appended for trail).",
+            formatValueFeedbackStatusLine(resolved),
+        ];
+        return { exitCode: 0, stdout: `${lines.join("\n")}\n`, changed };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes("PROJECT-DEFINITION not found")) {
+            return { exitCode: 2, stdout: `\u274c ${message}\n`, changed: false };
+        }
+        return { exitCode: 2, stdout: `\u274c Config error: ${message}\n`, changed: false };
+    }
+}
+//# sourceMappingURL=value-feedback.js.map

package/dist/preflight-cache/evaluate.js

@@ -14,15 +14,16 @@ import { execFileSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join, relative } from "node:path";
 import { probeCacheDrift } from "../cache/fetch.js";
-import { resolveEvalPath, resolveProjectDefinitionPath } from "../layout/resolve.js";
+import { resolveProjectDefinitionPath } from "../layout/resolve.js";
 import { readPlanPolicy } from "../policy/plan-extensions.js";
 import { latestDecisionForIssue as auditLatestDecisionForIssue } from "../triage/actions/candidates-log.js";
+import { resolveCandidatesLogPath } from "../triage/cache-path.js";
 // ---------------------------------------------------------------------------
 // Public constants (mirror preflight_cache.py)
 // ---------------------------------------------------------------------------
 export const CACHE_DIR_NAME = ".deft-cache";
 export const DEFAULT_SOURCE = "github-issue";
-export const CANDIDATES_RELPATH = join("vbrief", ".eval", "candidates.jsonl");
+export const CANDIDATES_RELPATH = join("vbrief", ".triage-cache", "candidates.jsonl");
 export const DEFAULT_MAX_AGE_HOURS = 24;
 export const ENV_MAX_AGE_HOURS = "DEFT_CACHE_MAX_AGE_HOURS";
 export const ENV_TRIAGE_REPO = "DEFT_TRIAGE_REPO";
@@ -335,7 +336,7 @@ export function evaluate(projectRoot, options = {}) {
         DEFAULT_MAX_AGE_HOURS;
     const cacheRoot = join(projectRoot, CACHE_DIR_NAME);
     // Layout-aware (#2109 part 2a): resolve under xbrief/.eval when migrated.
-    const candidatesPath = resolveEvalPath(projectRoot, "candidates.jsonl");
+    const candidatesPath = resolveCandidatesLogPath(projectRoot);
     // Step 1: Resolve repo slug
     const resolvedRepo = resolveRepo(projectRoot, cacheRoot, source, options.repo ?? null);
     // Step 2: Check cache dir exists

package/dist/scope/audit-log.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync, writeSync, } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { resolveEvalPath } from "../layout/resolve.js";
+import { resolveTriageCachePath } from "../triage/cache-path.js";
 import { utcNowIso } from "./vbrief-json.js";
 export class ScopeAuditLogError extends Error {
     constructor(message) {
@@ -94,8 +94,8 @@ export function newDecisionId() {
     return randomUUID();
 }
 export function canonicalLogPath(projectRoot) {
-    // Layout-aware (#2109 part 2a): xbrief/.eval when migrated, else vbrief/.eval.
-    return resolveEvalPath(resolve(projectRoot), "scope-lifecycle.jsonl");
+    // Layout-aware (#1703): triage working-set under `.triage-cache/`.
+    return resolveTriageCachePath(resolve(projectRoot), "scope-lifecycle.jsonl");
 }
 function withAppendLock(logPath, fn) {
     const lockPath = `${logPath}.lock`;

package/dist/scope/transition.js

@@ -1,5 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { InstrumentedVbriefCrud, persistCrudMetrics } from "../eval/crud-telemetry.js";
 import { hasArtifactSuffix } from "../layout/resolve.js";
 import { append, canonicalLogPath, newDecisionId } from "./audit-log.js";
 import { stampCompletionMetadata } from "./capacity-stamp.js";
@@ -78,14 +79,24 @@ export function runTransition(action, filePath, now = new Date()) {
     const nowIso = utcNowIso(now);
     planObj.status = targetStatus;
     planObj.updated = nowIso;
+    const vbriefRoot = dirname(dirname(resolvedPath));
+    const projectRoot = dirname(vbriefRoot);
     if (act === "complete") {
-        const vbriefRoot = dirname(dirname(resolvedPath));
-        const projectRoot = dirname(vbriefRoot);
         stampCompletionMetadata(planObj, projectRoot, nowIso);
     }
-    writeFileSync(resolvedPath, formatVbriefJson(data), "utf8");
+    const formatted = formatVbriefJson(data);
+    const crud = new InstrumentedVbriefCrud({ now: () => now });
+    const writeResult = crud.update(resolvedPath, formatted, { trustedWrite: true });
+    if (!writeResult.ok) {
+        return { ok: false, message: writeResult.error ?? `CRUD update failed for ${resolvedPath}` };
+    }
+    try {
+        persistCrudMetrics(projectRoot, crud.getMetrics());
+    }
+    catch {
+        /* best-effort telemetry persistence */
+    }
     if (targetFolder !== null) {
-        const vbriefRoot = dirname(dirname(resolvedPath));
         const destDir = join(vbriefRoot, targetFolder);
         mkdirSync(destDir, { recursive: true });
         const destPath = join(destDir, basename);