@deftai/directive-core 0.83.0 → 0.85.0

package/dist/policy/org-force-on-migration.d.ts

@@ -0,0 +1,44 @@
+import { type OrgAutoEnableOptions } from "./value-feedback-autoenable.js";
+/** Durable once-per-checkout marker for #2822 trusted-org install force-on. */
+export declare const ORG_FORCE_ON_MARKER_REL: string;
+export declare const ORG_FORCE_ON_MARKER_VERSION: 1;
+export interface OrgForceOnMarker {
+    readonly version: typeof ORG_FORCE_ON_MARKER_VERSION;
+    readonly appliedAt: string;
+    readonly originOrg: string;
+    readonly valueFeedback: boolean;
+    readonly productSignal: boolean;
+    readonly directiveVersion: string;
+}
+/** Canonical typed block written by the one-time migration (#2822 Part A). */
+export declare const FORCE_ON_VALUE_FEEDBACK_BLOCK: {
+    readonly enabled: true;
+    readonly emitEvents: true;
+    readonly sessionLine: true;
+    readonly upstreamPrompt: false;
+};
+/** Read the #2822 migration marker when present and valid. */
+export declare function readOrgForceOnMarker(projectRoot: string): OrgForceOnMarker | null;
+export interface RunOrgForceOnMigrationOptions {
+    readonly autoEnable?: OrgAutoEnableOptions;
+    readonly actor?: string;
+    readonly now?: Date;
+}
+export interface OrgForceOnMigrationResult {
+    readonly ran: boolean;
+    readonly skippedReason: string | null;
+    readonly valueFeedbackChanged: boolean;
+    readonly productSignalChanged: boolean;
+}
+/**
+ * One-time trusted-org install/upgrade force-on for valueFeedback + productSignal
+ * (#2822). Idempotent via durable marker; non-trusted orgs are unchanged.
+ */
+export declare function runOrgForceOnMigration(projectRoot: string, options?: RunOrgForceOnMigrationOptions): OrgForceOnMigrationResult;
+/** True when typed valueFeedback matches the #2822 force-on block shape. */
+export declare function isForceOnValueFeedbackBlock(raw: unknown): boolean;
+/** Resolve auditable source for valueFeedback after #2822 migration. */
+export declare function valueFeedbackInstallForceOnSource(projectRoot: string, raw: unknown): "install-force-on" | null;
+/** Resolve auditable source for productSignal after #2822 migration. */
+export declare function productSignalInstallForceOnSource(projectRoot: string, raw: unknown): "install-force-on" | null;
+//# sourceMappingURL=org-force-on-migration.d.ts.map

package/dist/policy/org-force-on-migration.js

@@ -0,0 +1,240 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { readCorePackageVersion } from "../engine-version.js";
+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";
+import { detectOriginOrg, isTrustedOrgAutoEnable, } from "./value-feedback-autoenable.js";
+/** Durable once-per-checkout marker for #2822 trusted-org install force-on. */
+export const ORG_FORCE_ON_MARKER_REL = join(".deft-cache", "org-force-on-v2822.json");
+export const ORG_FORCE_ON_MARKER_VERSION = 1;
+/** Canonical typed block written by the one-time migration (#2822 Part A). */
+export const FORCE_ON_VALUE_FEEDBACK_BLOCK = {
+    enabled: true,
+    emitEvents: true,
+    sessionLine: true,
+    upstreamPrompt: false,
+};
+const DEFAULT_PRODUCT_SIGNAL_SINK = "deftai/product-signal";
+function markerPath(projectRoot) {
+    return resolve(projectRoot, ORG_FORCE_ON_MARKER_REL);
+}
+function parseMarker(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        return null;
+    }
+    const rec = raw;
+    if (rec.version !== ORG_FORCE_ON_MARKER_VERSION ||
+        typeof rec.appliedAt !== "string" ||
+        typeof rec.originOrg !== "string" ||
+        typeof rec.valueFeedback !== "boolean" ||
+        typeof rec.productSignal !== "boolean" ||
+        typeof rec.directiveVersion !== "string") {
+        return null;
+    }
+    return {
+        version: ORG_FORCE_ON_MARKER_VERSION,
+        appliedAt: rec.appliedAt,
+        originOrg: rec.originOrg,
+        valueFeedback: rec.valueFeedback,
+        productSignal: rec.productSignal,
+        directiveVersion: rec.directiveVersion,
+    };
+}
+/** Read the #2822 migration marker when present and valid. */
+export function readOrgForceOnMarker(projectRoot) {
+    const path = markerPath(projectRoot);
+    if (!existsSync(path)) {
+        return null;
+    }
+    try {
+        return parseMarker(JSON.parse(readFileSync(path, "utf8")));
+    }
+    catch {
+        return null;
+    }
+}
+function writeOrgForceOnMarker(projectRoot, marker) {
+    const path = markerPath(projectRoot);
+    mkdirSync(join(path, ".."), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(marker, null, 2)}\n`, "utf8");
+}
+function readTypedBoolean(raw, key, fallback) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return fallback;
+    }
+    const value = raw[key];
+    return typeof value === "boolean" ? value : fallback;
+}
+function valueFeedbackNeedsForceOn(raw) {
+    const enabled = readTypedBoolean(raw, "enabled", false);
+    if (!enabled) {
+        return true;
+    }
+    const emitEvents = readTypedBoolean(raw, "emitEvents", true);
+    const sessionLine = readTypedBoolean(raw, "sessionLine", true);
+    const upstreamPrompt = readTypedBoolean(raw, "upstreamPrompt", false);
+    return !emitEvents || !sessionLine || upstreamPrompt;
+}
+function productSignalNeedsForceOn(raw) {
+    return !readTypedBoolean(raw, "enabled", false);
+}
+function ensurePolicyBlock(plan) {
+    migrateLegacyPolicyKey(plan);
+    const existing = plan[PLAN_POLICY_KEY];
+    if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
+        if (existing === undefined) {
+            plan[PLAN_POLICY_KEY] = {};
+        }
+        else {
+            throw new Error("plan.policy is not an object");
+        }
+    }
+    return plan[PLAN_POLICY_KEY];
+}
+function writeMarkerForSkip(projectRoot, options, valueFeedback, productSignal) {
+    const originOrg = detectOriginOrg(projectRoot, options.autoEnable) ?? "unknown";
+    const now = options.now ?? new Date();
+    writeOrgForceOnMarker(projectRoot, {
+        version: ORG_FORCE_ON_MARKER_VERSION,
+        appliedAt: now.toISOString().replace(/\.\d{3}Z$/, "Z"),
+        originOrg,
+        valueFeedback,
+        productSignal,
+        directiveVersion: readCorePackageVersion(),
+    });
+}
+/**
+ * One-time trusted-org install/upgrade force-on for valueFeedback + productSignal
+ * (#2822). Idempotent via durable marker; non-trusted orgs are unchanged.
+ */
+export function runOrgForceOnMigration(projectRoot, options = {}) {
+    if (readOrgForceOnMarker(projectRoot) !== null) {
+        return {
+            ran: false,
+            skippedReason: "marker-present",
+            valueFeedbackChanged: false,
+            productSignalChanged: false,
+        };
+    }
+    if (!isTrustedOrgAutoEnable(projectRoot, options.autoEnable)) {
+        return {
+            ran: false,
+            skippedReason: "non-trusted-org",
+            valueFeedbackChanged: false,
+            productSignalChanged: false,
+        };
+    }
+    const [data, err] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return {
+            ran: false,
+            skippedReason: err ?? "project-definition-missing",
+            valueFeedbackChanged: false,
+            productSignalChanged: false,
+        };
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    const policyObj = typeof policyBlock === "object" && policyBlock !== null && !Array.isArray(policyBlock)
+        ? policyBlock
+        : {};
+    const vfRaw = "valueFeedback" in policyObj ? policyObj.valueFeedback : undefined;
+    const psRaw = "productSignal" in policyObj ? policyObj.productSignal : undefined;
+    const needsVf = valueFeedbackNeedsForceOn(vfRaw);
+    const needsPs = productSignalNeedsForceOn(psRaw);
+    if (!needsVf && !needsPs) {
+        writeMarkerForSkip(projectRoot, options, false, false);
+        return {
+            ran: false,
+            skippedReason: "already-enabled",
+            valueFeedbackChanged: false,
+            productSignalChanged: false,
+        };
+    }
+    const path = projectDefinitionPath(projectRoot);
+    let valueFeedbackChanged = false;
+    let productSignalChanged = false;
+    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 rootData = parsed;
+        if (typeof rootData.plan !== "object" ||
+            rootData.plan === null ||
+            Array.isArray(rootData.plan)) {
+            if (rootData.plan === undefined) {
+                rootData.plan = {};
+            }
+            else {
+                throw new Error("PROJECT-DEFINITION 'plan' is not an object");
+            }
+        }
+        const plan = rootData.plan;
+        const policy = ensurePolicyBlock(plan);
+        const previousVf = policy.valueFeedback;
+        const previousPs = policy.productSignal;
+        if (needsVf) {
+            policy.valueFeedback = { ...FORCE_ON_VALUE_FEEDBACK_BLOCK };
+            valueFeedbackChanged = valueFeedbackNeedsForceOn(previousVf);
+        }
+        if (needsPs) {
+            const prevObj = typeof previousPs === "object" && previousPs !== null && !Array.isArray(previousPs)
+                ? previousPs
+                : {};
+            const sinkRepo = typeof prevObj.sinkRepo === "string" && prevObj.sinkRepo.trim().length > 0
+                ? prevObj.sinkRepo.trim()
+                : DEFAULT_PRODUCT_SIGNAL_SINK;
+            policy.productSignal = { enabled: true, sinkRepo };
+            productSignalChanged = productSignalNeedsForceOn(previousPs);
+        }
+        if (valueFeedbackChanged || productSignalChanged) {
+            atomicWriteProjectDefinition(path, rootData);
+        }
+        const actor = options.actor ?? "directive-update";
+        appendAuditLog(projectRoot, [
+            `actor=${actor}`,
+            "org-force-on-v2822",
+            `valueFeedback=${needsVf ? "forced-on" : "unchanged"}`,
+            `productSignal=${needsPs ? "forced-on" : "unchanged"}`,
+            `previousValueFeedback=${JSON.stringify(previousVf ?? null)}`,
+            `previousProductSignal=${JSON.stringify(previousPs ?? null)}`,
+        ].join(" "));
+        writeMarkerForSkip(projectRoot, options, needsVf, needsPs);
+        return { changed: valueFeedbackChanged || productSignalChanged };
+    });
+    return {
+        ran: true,
+        skippedReason: null,
+        valueFeedbackChanged,
+        productSignalChanged,
+    };
+}
+/** True when typed valueFeedback matches the #2822 force-on block shape. */
+export function isForceOnValueFeedbackBlock(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return false;
+    }
+    const block = raw;
+    return (block.enabled === FORCE_ON_VALUE_FEEDBACK_BLOCK.enabled &&
+        readTypedBoolean(raw, "emitEvents", false) === FORCE_ON_VALUE_FEEDBACK_BLOCK.emitEvents &&
+        readTypedBoolean(raw, "sessionLine", false) === FORCE_ON_VALUE_FEEDBACK_BLOCK.sessionLine &&
+        readTypedBoolean(raw, "upstreamPrompt", true) === FORCE_ON_VALUE_FEEDBACK_BLOCK.upstreamPrompt);
+}
+/** Resolve auditable source for valueFeedback after #2822 migration. */
+export function valueFeedbackInstallForceOnSource(projectRoot, raw) {
+    const marker = readOrgForceOnMarker(projectRoot);
+    if (marker === null || !marker.valueFeedback) {
+        return null;
+    }
+    return isForceOnValueFeedbackBlock(raw) ? "install-force-on" : null;
+}
+/** Resolve auditable source for productSignal after #2822 migration. */
+export function productSignalInstallForceOnSource(projectRoot, raw) {
+    const marker = readOrgForceOnMarker(projectRoot);
+    if (marker === null || !marker.productSignal) {
+        return null;
+    }
+    return readTypedBoolean(raw, "enabled", false) ? "install-force-on" : null;
+}
+//# sourceMappingURL=org-force-on-migration.js.map

package/dist/policy/product-signal.d.ts

@@ -9,7 +9,7 @@ export interface ProductSignalConfig {
     readonly enabled: boolean;
     readonly sinkRepo: string;
 }
-export type ProductSignalSource = "typed" | "default" | "default-on-error";
+export type ProductSignalSource = "typed" | "install-force-on" | "default" | "default-on-error";
 export interface ProductSignalResolved extends ProductSignalConfig {
     readonly source: ProductSignalSource;
     readonly error: string | null;
@@ -17,6 +17,8 @@ export interface ProductSignalResolved extends ProductSignalConfig {
 export declare const PRODUCT_SIGNAL_CAPABILITY_COST_DISCLOSURE: string;
 /** Validate a `plan.policy.productSignal` payload. */
 export declare function validateProductSignal(value: unknown): string[];
+/** Resolve a typed `productSignal` block without install-force-on overlay. */
+export declare function resolveProductSignalFromTypedBlock(raw: unknown): ProductSignalResolved;
 /** Resolve `plan.policy.productSignal` from PROJECT-DEFINITION (#2693). */
 export declare function resolveProductSignal(projectRoot: string): ProductSignalResolved;
 /** Human-readable status line for CLI surfaces. */

package/dist/policy/product-signal.js

@@ -1,5 +1,6 @@
 import { readFileSync } from "node:fs";
 import { atomicWriteProjectDefinition, projectDefinitionMutationLock, } from "../vbrief-build/project-definition-io.js";
+import { productSignalInstallForceOnSource } from "./org-force-on-migration.js";
 import { migrateLegacyPolicyKey, PLAN_POLICY_KEY, readPlanPolicy } from "./plan-extensions.js";
 import { policyColonInvocation } from "./policy-invocation.js";
 import { appendAuditLog, loadProjectDefinition, projectDefinitionPath } from "./resolve.js";
@@ -48,7 +49,8 @@ export function validateProductSignal(value) {
     }
     return errors;
 }
-function resolveFromPolicyBlock(raw) {
+/** Resolve a typed `productSignal` block without install-force-on overlay. */
+export function resolveProductSignalFromTypedBlock(raw) {
     const errors = validateProductSignal(raw);
     if (errors.length > 0) {
         return defaultResolved("default-on-error", errors[0] ?? "invalid productSignal block");
@@ -81,7 +83,13 @@ export function resolveProductSignal(projectRoot) {
         !("productSignal" in policyBlock)) {
         return defaultResolved("default");
     }
-    return resolveFromPolicyBlock(policyBlock.productSignal);
+    const raw = policyBlock.productSignal;
+    const installSource = productSignalInstallForceOnSource(projectRoot, raw);
+    if (installSource !== null) {
+        const resolved = resolveProductSignalFromTypedBlock(raw);
+        return { ...resolved, source: installSource };
+    }
+    return resolveProductSignalFromTypedBlock(raw);
 }
 /** Human-readable status line for CLI surfaces. */
 export function formatProductSignalStatusLine(policy) {
@@ -117,7 +125,10 @@ export function inspectProductSignal(data, projectRoot) {
         }
         return fieldFromResolved(defaultResolved("default"));
     }
-    return fieldFromResolved(resolveFromPolicyBlock(policyBlock.productSignal));
+    const raw = policyBlock.productSignal;
+    const installSource = projectRoot !== undefined ? productSignalInstallForceOnSource(projectRoot, raw) : null;
+    const resolved = resolveProductSignalFromTypedBlock(raw);
+    return fieldFromResolved(installSource !== null ? { ...resolved, source: installSource } : resolved);
 }
 /** Persist `productSignal.enabled=true` after capability-cost disclosure (#2693). */
 export function enableProductSignal(projectRoot, options) {
@@ -168,7 +179,7 @@ export function enableProductSignal(projectRoot, options) {
                     ? prevObj.sinkRepo.trim()
                     : DEFAULT_PRODUCT_SIGNAL_SINK_REPO);
             const nextBlock = { enabled: true, sinkRepo };
-            const previousNormalized = resolveFromPolicyBlock(previous);
+            const previousNormalized = resolveProductSignalFromTypedBlock(previous);
             const changedFlag = previousNormalized.enabled !== nextBlock.enabled ||
                 previousNormalized.sinkRepo !== nextBlock.sinkRepo;
             policyBlock.productSignal = nextBlock;

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

@@ -17,7 +17,7 @@ export interface ValueFeedbackConfig {
     readonly sessionLine: boolean;
     readonly upstreamPrompt: boolean;
 }
-export type ValueFeedbackSource = "typed" | "org-auto" | "default" | "default-on-error";
+export type ValueFeedbackSource = "typed" | "org-auto" | "install-force-on" | "default" | "default-on-error";
 export interface ValueFeedbackResolved extends ValueFeedbackConfig {
     readonly source: ValueFeedbackSource;
     readonly error: string | null;
@@ -25,6 +25,8 @@ export interface ValueFeedbackResolved extends ValueFeedbackConfig {
 export declare const VALUE_FEEDBACK_CAPABILITY_COST_DISCLOSURE: string;
 /** Validate a `plan.policy.valueFeedback` payload. */
 export declare function validateValueFeedback(value: unknown): string[];
+/** Resolve a typed `valueFeedback` block without org-auto / install-force-on layers. */
+export declare function resolveValueFeedbackFromTypedBlock(raw: unknown): ValueFeedbackResolved;
 export interface ResolveValueFeedbackOptions {
     /** Test seam for origin-org auto-enable resolution (#2376). */
     readonly autoEnable?: OrgAutoEnableOptions;
@@ -78,4 +80,19 @@ export interface EnableValueFeedbackResult {
 }
 /** Persist `valueFeedback.enabled=true` after capability-cost disclosure (#1709). */
 export declare function enableValueFeedback(projectRoot: string, options: EnableValueFeedbackOptions): EnableValueFeedbackResult;
+export interface ClearValueFeedbackOptions {
+    readonly actor?: string;
+    readonly note?: string;
+}
+export interface ClearValueFeedbackResult {
+    readonly exitCode: 0 | 2;
+    readonly stdout: string;
+    readonly changed: boolean;
+}
+/**
+ * Remove the typed `valueFeedback` key so trusted-org resolution can return to
+ * org-auto (#2822). Does not delete the install-force-on marker — subsequent
+ * updates will not re-force against intentional opt-out.
+ */
+export declare function clearValueFeedback(projectRoot: string, options?: ClearValueFeedbackOptions): ClearValueFeedbackResult;
 //# sourceMappingURL=value-feedback.d.ts.map

package/dist/policy/value-feedback.js

@@ -1,5 +1,6 @@
 import { readFileSync } from "node:fs";
 import { atomicWriteProjectDefinition, projectDefinitionMutationLock, } from "../vbrief-build/project-definition-io.js";
+import { valueFeedbackInstallForceOnSource } from "./org-force-on-migration.js";
 import { migrateLegacyPolicyKey, PLAN_POLICY_KEY, readPlanPolicy } from "./plan-extensions.js";
 import { policyColonInvocation } from "./policy-invocation.js";
 import { appendAuditLog, loadProjectDefinition, projectDefinitionPath } from "./resolve.js";
@@ -77,7 +78,8 @@ export function validateValueFeedback(value) {
     }
     return errors;
 }
-function resolveFromPolicyBlock(raw) {
+/** Resolve a typed `valueFeedback` block without org-auto / install-force-on layers. */
+export function resolveValueFeedbackFromTypedBlock(raw) {
     const errors = validateValueFeedback(raw);
     if (errors.length > 0) {
         return defaultResolved("default-on-error", errors[0] ?? "invalid valueFeedback block");
@@ -130,7 +132,13 @@ export function resolveValueFeedback(projectRoot, options = {}) {
         }
         return defaultResolved("default");
     }
-    return resolveFromPolicyBlock(policyBlock.valueFeedback);
+    const raw = policyBlock.valueFeedback;
+    const installSource = valueFeedbackInstallForceOnSource(projectRoot, raw);
+    if (installSource !== null) {
+        const resolved = resolveValueFeedbackFromTypedBlock(raw);
+        return { ...resolved, source: installSource };
+    }
+    return resolveValueFeedbackFromTypedBlock(raw);
 }
 /** Master gate: when `enabled` is false, every downstream path is rejected. */
 export function isValueFeedbackPathAllowed(path, policy) {
@@ -196,8 +204,10 @@ export function inspectValueFeedback(data, projectRoot, options = {}) {
         }
         return fieldFromResolved(defaultResolved("default"));
     }
-    const resolved = resolveFromPolicyBlock(policyBlock.valueFeedback);
-    return fieldFromResolved(resolved);
+    const raw = policyBlock.valueFeedback;
+    const installSource = projectRoot !== undefined ? valueFeedbackInstallForceOnSource(projectRoot, raw) : null;
+    const resolved = resolveValueFeedbackFromTypedBlock(raw);
+    return fieldFromResolved(installSource !== null ? { ...resolved, source: installSource } : resolved);
 }
 /** Persist `valueFeedback.enabled=true` after capability-cost disclosure (#1709). */
 export function enableValueFeedback(projectRoot, options) {
@@ -259,7 +269,7 @@ export function enableValueFeedback(projectRoot, options) {
                 sessionLine: readPersistedSubFlag("sessionLine"),
                 upstreamPrompt: readPersistedSubFlag("upstreamPrompt"),
             };
-            const previousNormalized = resolveFromPolicyBlock(previous);
+            const previousNormalized = resolveValueFeedbackFromTypedBlock(previous);
             const changedFlag = previousNormalized.enabled !== nextBlock.enabled ||
                 previousNormalized.emitEvents !== nextBlock.emitEvents ||
                 previousNormalized.sessionLine !== nextBlock.sessionLine ||
@@ -302,4 +312,67 @@ export function enableValueFeedback(projectRoot, options) {
         return { exitCode: 2, stdout: `\u274c Config error: ${message}\n`, changed: false };
     }
 }
+/**
+ * Remove the typed `valueFeedback` key so trusted-org resolution can return to
+ * org-auto (#2822). Does not delete the install-force-on marker — subsequent
+ * updates will not re-force against intentional opt-out.
+ */
+export function clearValueFeedback(projectRoot, options = {}) {
+    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)) {
+                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)) {
+                return { changed: false };
+            }
+            const policyBlock = existingPolicy;
+            if (!("valueFeedback" in policyBlock)) {
+                return { changed: false };
+            }
+            const previous = policyBlock.valueFeedback;
+            delete policyBlock.valueFeedback;
+            atomicWriteProjectDefinition(path, data);
+            const actor = options.actor ?? policyColonInvocation("clear-value-feedback");
+            const note = options.note ?? "";
+            const parts = [
+                `actor=${actor}`,
+                "valueFeedback=cleared",
+                `previous=${JSON.stringify(previous ?? null)}`,
+            ];
+            if (note) {
+                parts.push(`note=${note.replace(/\n/g, " ").replace(/\r/g, " ")}`);
+            }
+            appendAuditLog(projectRoot, parts.join(" "));
+            return { changed: true };
+        });
+        const resolved = resolveValueFeedback(projectRoot);
+        const lines = [
+            `\u2713 ${FIELD_VALUE_FEEDBACK} typed key removed (resolution returns to org-auto/default).`,
+            changed
+                ? "  audit: meta/policy-changes.log updated."
+                : "  no-op: typed key was already absent.",
+            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,7 +14,7 @@ import { execFileSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join, relative } from "node:path";
 import { isTriageCacheEmpty, maybeAutoPopulateEmptyCache } from "../cache/empty-populate.js";
-import { probeCacheDrift } from "../cache/fetch.js";
+import { probeCacheDrift, readOpenInventoryStamp, } from "../cache/fetch.js";
 import { resolveProjectDefinitionPath } from "../layout/resolve.js";
 import { recoveryHintForStaleFailure } from "../session/cache-recovery.js";
 export { recoveryHintForStaleFailure } from "../session/cache-recovery.js";
@@ -423,6 +423,17 @@ function evaluateWithContext(projectRoot, options, ctx) {
             minMetaPath = p;
         }
     }
+    // #2826: empty open inventory with a successful fetch stamp is fresh — not
+    // the never-fetched case that yields minFetchedAt=null / Infinity age.
+    if (minFetchedAt === null && rawCandidatePaths.length === 0 && resolvedRepo !== null) {
+        const stamp = readOpenInventoryStamp(cacheRoot, source, resolvedRepo);
+        if (stamp !== null) {
+            const parsed = new Date(stamp.fetched_at);
+            if (!Number.isNaN(parsed.getTime())) {
+                minFetchedAt = parsed;
+            }
+        }
+    }
     const now = nowFn();
     const ageMs = minFetchedAt !== null ? now.getTime() - minFetchedAt.getTime() : Infinity;
     const ageH = ageMs / (1000 * 3600);

package/dist/product-signal/consent-prompt.d.ts

@@ -0,0 +1,13 @@
+import { type HeadlessDetectionOptions } from "./headless.js";
+/** D17 first-time consent ask (#2693 / #2822). */
+export declare const PRODUCT_SIGNAL_CONSENT_PROMPT: string;
+export interface ProductSignalConsentEligibilityOptions extends HeadlessDetectionOptions {
+    readonly projectRoot: string;
+}
+/** True when an interactive session should surface the D17 consent ask (#2822 AC). */
+export declare function isProductSignalConsentEligible(options: ProductSignalConsentEligibilityOptions): boolean;
+/** Format the D17 consent ask for session start / status surfaces. */
+export declare function formatProductSignalConsentPrompt(): string;
+/** Emit the D17 ask when eligible; headless callers get an empty string (#2693 D16). */
+export declare function maybeFormatProductSignalConsentPrompt(options: ProductSignalConsentEligibilityOptions): string;
+//# sourceMappingURL=consent-prompt.d.ts.map

package/dist/product-signal/consent-prompt.js

@@ -0,0 +1,30 @@
+import { resolveProductSignal } from "../policy/product-signal.js";
+import { isProductSignalConsented } from "./consent.js";
+import { isHeadlessSession } from "./headless.js";
+/** D17 first-time consent ask (#2693 / #2822). */
+export const PRODUCT_SIGNAL_CONSENT_PROMPT = "May we collect usage metrics and related session signal from this install to improve Directive? " +
+    "This can include a short check-in plus minimized local summaries (value/health and related ledgers). " +
+    "Nothing is sent while this path is off or without your consent.\n\n" +
+    "If you are unsure, please check with your company before saying no — they are a Directive partner " +
+    "and may already expect this signal to be shared.\n\n" +
+    "Reply **yes** to consent (`task product-signal:consent -- --grant`), or **no** to decline.";
+/** True when an interactive session should surface the D17 consent ask (#2822 AC). */
+export function isProductSignalConsentEligible(options) {
+    if (isHeadlessSession(options)) {
+        return false;
+    }
+    const policy = resolveProductSignal(options.projectRoot);
+    if (!policy.enabled) {
+        return false;
+    }
+    return !isProductSignalConsented({ env: options.env });
+}
+/** Format the D17 consent ask for session start / status surfaces. */
+export function formatProductSignalConsentPrompt() {
+    return `[deft product-signal] First-time consent eligible:\n${PRODUCT_SIGNAL_CONSENT_PROMPT}\n`;
+}
+/** Emit the D17 ask when eligible; headless callers get an empty string (#2693 D16). */
+export function maybeFormatProductSignalConsentPrompt(options) {
+    return isProductSignalConsentEligible(options) ? formatProductSignalConsentPrompt() : "";
+}
+//# sourceMappingURL=consent-prompt.js.map

package/dist/product-signal/submit.js

@@ -1,9 +1,11 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 import { enableProductSignal, formatProductSignalStatusLine, resolveProductSignal, } from "../policy/product-signal.js";
 import { resolveProjectRoot } from "../scope/project-context.js";
 import { resolveActorName } from "./actor-name.js";
 import { authorizeProductSignalSink, grantProductSignalConsent, readProductSignalConsent, revokeProductSignalConsent, } from "./consent.js";
+import { maybeFormatProductSignalConsentPrompt } from "./consent-prompt.js";
 import { evaluateProductSignalGates } from "./gates.js";
 import { GitHubPrivateSinkAdapter } from "./github-private-sink-adapter.js";
 import { collectInstallContext } from "./install-context.js";
@@ -13,6 +15,7 @@ import { bootstrapProductSignalSink } from "./sink-bootstrap.js";
 export const PRODUCT_SIGNAL_LAST_SUBMIT_REL = join(".deft-cache", "product-signal-last-submit.json");
 function recordLastSubmit(projectRoot, outcome, url) {
     const path = resolve(projectRoot, PRODUCT_SIGNAL_LAST_SUBMIT_REL);
+    assertWriteTargetSafe(projectRoot, path);
     try {
         mkdirSync(join(path, ".."), { recursive: true });
         appendFileSync(path, `${JSON.stringify({
@@ -127,7 +130,21 @@ export async function submitProductSignal(options) {
     const adapter = new GitHubPrivateSinkAdapter({ sinkRepo: policy.sinkRepo });
     const result = await adapter.submit(payload, { gapText: options.gapText });
     if (result.outcome === "submitted") {
-        recordLastSubmit(root, result.outcome, result.issueUrl ?? null);
+        try {
+            recordLastSubmit(root, result.outcome, result.issueUrl ?? null);
+        }
+        catch (err) {
+            if (err instanceof ProjectionContainmentError) {
+                return {
+                    outcome: "error-config",
+                    exitCode: 2,
+                    message: `${err.message}\n`,
+                    issueUrl: result.issueUrl,
+                    payload,
+                };
+            }
+            throw err;
+        }
     }
     const urlLine = result.issueUrl ? ` url=${result.issueUrl}` : "";
     return {
@@ -150,6 +167,10 @@ export function runProductSignalStatus(projectRoot) {
         `[deft product-signal] consented=${String(consent !== null)} configuredSink=${configuredSink} consentedSink=${sinkAuth.consentedSink ?? "none"} sinksMatch=${String(sinkAuth.sinksMatch)}`,
         last ? `[deft product-signal] ${last}` : "[deft product-signal] last submit: none",
     ];
+    const consentPrompt = maybeFormatProductSignalConsentPrompt({ projectRoot: root });
+    if (consentPrompt.length > 0) {
+        lines.push(consentPrompt.trimEnd());
+    }
     return { exitCode: 0, text: `${lines.join("\n")}\n` };
 }
 export function runProductSignalEnable(projectRoot, confirm) {

package/dist/render/index.d.ts

@@ -8,6 +8,7 @@ export * as projectRender from "./project-render.js";
 export { acknowledgeProjectDefinitionStaleness, buildStalenessAcknowledgement, computeStalenessFlags, flagStaleNarratives, main as projectRenderMain, parseStalenessReview, renderProjectDefinition, scanLifecycleFolders, unacknowledgedCompletedItems, } from "./project-render.js";
 export * as roadmapRender from "./roadmap-render.js";
 export { checkDrift, generateRoadmapContent, main as roadmapRenderMain, renderRoadmap, renderRoadmapToBuffer, } from "./roadmap-render.js";
+export { main as ruleMapMain } from "./rule-map.js";
 export { aggregateScopeSection, buildScopeOutlookSection } from "./scope-outlook.js";
 export * as specRender from "./spec-render.js";
 export { main as specRenderMain, parseIncludeScopesFlag, renderSpec } from "./spec-render.js";

package/dist/render/index.js

@@ -8,6 +8,7 @@ export * as projectRender from "./project-render.js";
 export { acknowledgeProjectDefinitionStaleness, buildStalenessAcknowledgement, computeStalenessFlags, flagStaleNarratives, main as projectRenderMain, parseStalenessReview, renderProjectDefinition, scanLifecycleFolders, unacknowledgedCompletedItems, } from "./project-render.js";
 export * as roadmapRender from "./roadmap-render.js";
 export { checkDrift, generateRoadmapContent, main as roadmapRenderMain, renderRoadmap, renderRoadmapToBuffer, } from "./roadmap-render.js";
+export { main as ruleMapMain } from "./rule-map.js";
 export { aggregateScopeSection, buildScopeOutlookSection } from "./scope-outlook.js";
 export * as specRender from "./spec-render.js";
 export { main as specRenderMain, parseIncludeScopesFlag, renderSpec } from "./spec-render.js";