@deftai/directive-core 0.84.0 → 0.85.0

package/dist/init-deposit/refresh.d.ts

@@ -47,6 +47,8 @@ export interface RefreshDepositSeams {
     gitLsFiles?: GitLsFiles;
     /** #2530: injected git config seams for {@link writeConsumerGitHooks}. */
     gitHooks?: GitHooksSeams;
+    /** #2822: optional seam for trusted-org policy force-on migration. */
+    runOrgForceOn?: (projectRoot: string) => void;
 }
 /**
  * The four states `directive update` classifies an EXISTING install into BEFORE

package/dist/init-deposit/refresh.js

@@ -18,11 +18,13 @@ import { resolveInstalledContentRoot } from "../deposit/resolve-content.js";
 import { manifestTagToVersion, parseInstallManifest } from "../doctor/manifest.js";
 import { readCorePackageVersion } from "../engine-version.js";
 import { resolveLifecycleRoot } from "../layout/resolve.js";
+import { runOrgForceOnMigration } from "../policy/org-force-on-migration.js";
 import { checkLocalEngineIntegrity, classify, ENGINE_PACKAGE, plan, renderGlobalInstall, resolveEngine, } from "../resolution/index.js";
 import { gitPorcelain } from "../story-ready/git.js";
+import { removeStaleMigratedFrameworkNarrative } from "../xbrief-migrate/migrate-project.js";
 import { writeAgentHookDeposit } from "./agent-hooks.js";
 import { ensureInitGitignoreLines, isDepositTrackedInGit } from "./gitignore.js";
-import { depositStagePaths, isInstallerManagedPath, printCommitGuidance, pruneStrayDepositPaths, } from "./hygiene.js";
+import { depositStagePaths, isInstallerManagedPath, printCommitGuidance, prunePackageAbsentDepositPaths, } from "./hygiene.js";
 import { parseInitArgv } from "./init-deposit.js";
 import { buildLegacyRefusalJson, buildLegacyRefusalMessage, detectLegacyLayout, LEGACY_LAYOUT_REFUSED_EXIT_CODE, LegacyLayoutRefusedError, } from "./legacy-detect.js";
 import { printMigrateNudgeIfNeeded } from "./migrate.js";
@@ -409,10 +411,10 @@ export async function runRefreshDeposit(args, io, seams = {}) {
     else {
         await copyContent(contentRoot, deftDir);
         await prunePythonArtifactsFromDeposit(deftDir, projectDir, io);
-        // #2347: prune framework-source paths that the content package does not ship.
-        // The additive file-swap never removes them, causing the deposit-hygiene
-        // advisory to persist across every upgrade until manually cleaned.
-        await pruneStrayDepositPaths(deftDir, contentRoot, io);
+        // #2804 / #2347: prune deposit paths absent from the content package. The
+        // additive file-swap never removes them, causing stale bridge-era files to
+        // survive across upgrades until manually cleaned.
+        await prunePackageAbsentDepositPaths(deftDir, contentRoot, io);
         const nowIso = seams.nowIso ?? (() => new Date().toISOString().replace(/\.\d{3}Z$/, "Z"));
         const manifestFields = {
             ref: contentVersion.startsWith("v") ? contentVersion : `v${contentVersion}`,
@@ -441,6 +443,17 @@ export async function runRefreshDeposit(args, io, seams = {}) {
     // lifecycle content before migrate:xbrief can transactionally converge it.
     if (hasCanonicalXbriefLifecycle(projectDir)) {
         syncConsumerXbriefSchemas(projectDir, deftDir);
+        removeStaleMigratedFrameworkNarrative(projectDir);
+    }
+    const runOrgForceOn = seams.runOrgForceOn ??
+        ((root) => {
+            runOrgForceOnMigration(root, { actor: "directive-update" });
+        });
+    try {
+        runOrgForceOn(projectDir);
+    }
+    catch {
+        // Policy migration is best-effort; never block framework refresh (#2822).
     }
     const agentsMdUpdated = writeAgentsMd(projectDir, deftDir, io);
     writeAgentHookDeposit(projectDir, io);

package/dist/policy/index.d.ts

@@ -4,6 +4,7 @@ export * from "./capacity.js";
 export * from "./decisions.js";
 export * from "./disclosure.js";
 export * from "./host-hooks.js";
+export * from "./org-force-on-migration.js";
 export * from "./plan-extensions.js";
 export * from "./policy-invocation.js";
 export * from "./product-signal.js";
@@ -11,6 +12,7 @@ export * from "./resolve.js";
 export * from "./runtime-authority.js";
 export * from "./staleness-tickler.js";
 export * from "./value-feedback.js";
+export * from "./value-feedback-autoenable.js";
 export * from "./wip.js";
 export declare const FIELD_ALLOW_DIRECT_COMMITS = "plan.policy.allowDirectCommitsToMaster";
 export declare const FIELD_WIP_CAP = "plan.policy.wipCap";

package/dist/policy/index.js

@@ -12,6 +12,7 @@ export * from "./capacity.js";
 export * from "./decisions.js";
 export * from "./disclosure.js";
 export * from "./host-hooks.js";
+export * from "./org-force-on-migration.js";
 export * from "./plan-extensions.js";
 export * from "./policy-invocation.js";
 export * from "./product-signal.js";
@@ -19,6 +20,7 @@ export * from "./resolve.js";
 export * from "./runtime-authority.js";
 export * from "./staleness-tickler.js";
 export * from "./value-feedback.js";
+export * from "./value-feedback-autoenable.js";
 export * from "./wip.js";
 export const FIELD_ALLOW_DIRECT_COMMITS = "plan.policy.allowDirectCommitsToMaster";
 export const FIELD_WIP_CAP = "plan.policy.wipCap";

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