@deftai/directive-core 0.84.0 → 0.86.0

package/dist/init-deposit/legacy-detect.js

@@ -23,11 +23,13 @@
  *
  * Refs #1912, #1669.
  */
-import { statSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { rmSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { GO_BRIDGE_RELEASES_URL, UPGRADING_DOC_URL } from "../doctor/constants.js";
 import { extractManagedSection, parseInstallRootFromAgentsMd } from "../doctor/manifest.js";
 import { readTextSafe } from "../doctor/paths.js";
+import { gitPorcelain } from "../story-ready/git.js";
 /** Non-zero exit code for a use-time legacy-layout refusal (needs-action). */
 export const LEGACY_LAYOUT_REFUSED_EXIT_CODE = 2;
 const NOT_LEGACY = {
@@ -53,6 +55,16 @@ function defaultIsDir(p) {
     }
 }
 /** Does `.gitmodules` reference the deft framework at a deft install path? */
+const LEGACY_DEFT_DIR = "deft";
+function isFrameworkDeftDir(projectDir, isDir, isFile) {
+    const deftDir = join(projectDir, LEGACY_DEFT_DIR);
+    const deftMarkers = [
+        join(deftDir, "VERSION"),
+        join(deftDir, "main.md"),
+        join(deftDir, "Taskfile.yml"),
+    ];
+    return isDir(deftDir) && (deftMarkers.some((m) => isFile(m)) || isDir(join(deftDir, "skills")));
+}
 function gitmodulesReferencesFramework(text) {
     const normalized = text.replace(/\r\n/g, "\n").toLowerCase();
     if (normalized.includes("deftai/directive")) {
@@ -62,6 +74,27 @@ function gitmodulesReferencesFramework(text) {
     // when the url host differs (mirror, fork). Match `path = deft` / `path = .deft`.
     return /(^|\n)\s*path\s*=\s*\.?deft(\/|\s|$)/.test(normalized);
 }
+const DUAL_LAYOUT_DETAIL = "Found both the canonical .deft/core/ deposit and a leftover legacy deft/ " +
+    "framework tree -- remove deft/ so .deft/core/ is the sole framework root.";
+/**
+ * Detect a post-bridge dual-layout: canonical `.deft/core/` plus a leftover
+ * framework-marked `deft/` tree. Doctor-only -- the npm deposit path treats
+ * `.deft/core/` as canonical and must not refuse here (#2805 / #2804 wiring).
+ */
+export function detectDualLayout(projectDir, seams = {}) {
+    const isFile = seams.isFile ?? defaultIsFile;
+    const isDir = seams.isDir ?? defaultIsDir;
+    const hasCanonicalCore = isDir(join(projectDir, ".deft", "core"));
+    if (!hasCanonicalCore || !isFrameworkDeftDir(projectDir, isDir, isFile)) {
+        return null;
+    }
+    return {
+        legacy: true,
+        kind: "dual-layout",
+        detail: DUAL_LAYOUT_DETAIL,
+        evidence: [".deft/core/", "deft/"],
+    };
+}
 /**
  * Classify the on-disk layout at `projectDir`. Returns `legacy: false` for the
  * canonical `.deft/core/` vendored layout and for a greenfield project (so init
@@ -71,10 +104,11 @@ export function detectLegacyLayout(projectDir, seams = {}) {
     const isFile = seams.isFile ?? defaultIsFile;
     const isDir = seams.isDir ?? defaultIsDir;
     const readText = seams.readText ?? readTextSafe;
+    const hasCanonicalCore = isDir(join(projectDir, ".deft", "core"));
+    const deftDirIsFramework = isFrameworkDeftDir(projectDir, isDir, isFile);
     // Canonical vendored layout present -> the npm path owns it; not legacy. Any
-    // AGENTS.md / manifest drift here is repaired by the healthy refresh path,
-    // not by refusing.
-    if (isDir(join(projectDir, ".deft", "core"))) {
+    // leftover deft/ tree is a dual-layout hygiene issue surfaced by Doctor only.
+    if (hasCanonicalCore) {
         return NOT_LEGACY;
     }
     // Orphan `.deft/VERSION` (the old pre-`.deft/core/` manifest location) with no
@@ -92,13 +126,7 @@ export function detectLegacyLayout(projectDir, seams = {}) {
     // framework markers. Distinguish a git-clone / submodule deposit (a `.git`
     // inside `deft/`, or a `.gitmodules` pointing at the framework) from a plain
     // legacy-prefixed vendored copy.
-    const deftDir = join(projectDir, "deft");
-    const deftMarkers = [
-        join(deftDir, "VERSION"),
-        join(deftDir, "main.md"),
-        join(deftDir, "Taskfile.yml"),
-    ];
-    const deftDirIsFramework = isDir(deftDir) && (deftMarkers.some((m) => isFile(m)) || isDir(join(deftDir, "skills")));
+    const deftDir = join(projectDir, LEGACY_DEFT_DIR);
     if (deftDirIsFramework) {
         const submoduleGit = isFile(join(deftDir, ".git")) || isDir(join(deftDir, ".git"));
         if (submoduleGit) {
@@ -215,9 +243,113 @@ export function buildLegacyRefusalJson(command, projectDir, detection) {
 }
 /** One-line doctor signpost carrying the stable URL (no baked version/command). */
 export function legacyLayoutSignpostLine(detection) {
+    if (detection.kind === "dual-layout") {
+        return dualLayoutSignpostLine(detection);
+    }
     return (`Legacy Deft layout detected (${detection.kind ?? "unknown"}): ${detection.detail} ` +
         "Run the frozen Go bridge installer to migrate to .deft/core/, then use the npm " +
         `CLI (\`npx @deftai/directive update\`). See ${UPGRADING_DOC_URL} ` +
         `(frozen bridge: ${GO_BRIDGE_RELEASES_URL}).`);
 }
+/** Doctor / npm signpost for the post-bridge dual-layout state (#2805). */
+export function dualLayoutSignpostLine(detection) {
+    return (`Dual Deft layout detected (${detection.kind ?? "dual-layout"}): ${detection.detail} ` +
+        "Remove the legacy deft/ tree so .deft/core/ is the sole framework root " +
+        "(when clean: `git rm -r deft/`; reconcile local edits first if `git status deft/` is dirty). " +
+        `See ${UPGRADING_DOC_URL}.`);
+}
+function porcelainEntryPath(line) {
+    let path = line.slice(3).trim().replace(/\\/g, "/");
+    if (path.startsWith('"') && path.endsWith('"')) {
+        path = path.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+    }
+    return path;
+}
+function porcelainTouchesLegacyDeft(porcelain) {
+    const touched = [];
+    for (const line of porcelain.split("\n")) {
+        if (!line.trim())
+            continue;
+        const path = porcelainEntryPath(line);
+        if (path === LEGACY_DEFT_DIR || path.startsWith(`${LEGACY_DEFT_DIR}/`)) {
+            touched.push(path);
+        }
+    }
+    return touched;
+}
+/**
+ * Remove a clean tracked legacy `deft/` tree after bridge migration (#2805).
+ * Refuses when the tree has local modifications or untracked files.
+ */
+export function tryCleanupLegacyDeftTree(projectDir, seams = {}) {
+    const detection = detectDualLayout(projectDir);
+    if (detection === null) {
+        return {
+            ok: true,
+            action: "skipped",
+            detail: "No dual-layout legacy deft/ tree to remove.",
+        };
+    }
+    const readPorcelain = seams.gitPorcelain ?? gitPorcelain;
+    const porcelain = readPorcelain(projectDir);
+    if (porcelain === null) {
+        return {
+            ok: false,
+            action: "refused",
+            detail: "Cannot determine whether the legacy deft/ tree is clean (git unavailable). " +
+                "Inspect `git status deft/` and remove the tree manually once clean.",
+        };
+    }
+    const dirtyPaths = porcelainTouchesLegacyDeft(porcelain);
+    if (dirtyPaths.length > 0) {
+        return {
+            ok: false,
+            action: "refused",
+            detail: "Refusing to remove the legacy deft/ tree because it has local modifications or " +
+                "untracked files. Reconcile or commit those changes, then re-run " +
+                "`npx @deftai/directive update`, or remove deft/ manually once clean. " +
+                `Dirty paths: ${JSON.stringify(dirtyPaths.slice(0, 5))}` +
+                (dirtyPaths.length > 5 ? ", …" : "") +
+                ".",
+        };
+    }
+    const deftDir = join(projectDir, LEGACY_DEFT_DIR);
+    const removeDir = seams.removeDir ?? ((p) => rmSync(p, { recursive: true, force: true }));
+    const runGitRm = seams.runGitRm ??
+        ((root, relPath) => {
+            execFileSync("git", ["rm", "-r", "--ignore-unmatch", relPath], {
+                cwd: root,
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        });
+    try {
+        runGitRm(projectDir, LEGACY_DEFT_DIR);
+        removeDir(deftDir);
+        return {
+            ok: true,
+            action: "staged",
+            detail: "Removed the legacy deft/ framework tree and staged its deletion; " +
+                ".deft/core/ is now the sole framework root.",
+        };
+    }
+    catch {
+        try {
+            removeDir(deftDir);
+            return {
+                ok: true,
+                action: "removed",
+                detail: "Removed the legacy deft/ framework tree from disk; stage the deletion with " +
+                    "`git add -u deft/` if it was tracked.",
+            };
+        }
+        catch (cause) {
+            return {
+                ok: false,
+                action: "refused",
+                detail: `Could not remove the legacy deft/ tree: ${String(cause)}`,
+            };
+        }
+    }
+}
 //# sourceMappingURL=legacy-detect.js.map

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,242 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { readCorePackageVersion } from "../engine-version.js";
+import { assertWriteTargetSafe } from "../fs/projection-containment.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);
+    assertWriteTargetSafe(projectRoot, path);
+    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;