@deftai/directive-core 0.87.0 → 0.89.0

package/dist/policy/index.js

@@ -1,6 +1,8 @@
 import { FIELD_HOST_HOOKS, FIELD_HOST_HOOKS_CLI_ALIAS, inspectHostHooks } from "./host-hooks.js";
+import { FIELD_HOTFIX_CRITERIA, FIELD_HOTFIX_CRITERIA_CLI_ALIAS, inspectHotfixCriteria, } from "./hotfix-criteria.js";
 import { readPlanPolicy } from "./plan-extensions.js";
 import { FIELD_PRODUCT_SIGNAL, FIELD_PRODUCT_SIGNAL_CLI_ALIAS, inspectProductSignal, } from "./product-signal.js";
+import { FIELD_REQUIRE_HUMAN_MERGE, FIELD_REQUIRE_HUMAN_MERGE_CLI_ALIAS, inspectRequireHumanMerge, } from "./require-human-merge.js";
 import { coerceLegacyNarrative, LEGACY_NARRATIVE_KEY, loadProjectDefinition } from "./resolve.js";
 import { FIELD_RUNTIME_AUTHORITY, FIELD_RUNTIME_AUTHORITY_CLI_ALIAS, inspectRuntimeAuthority, } from "./runtime-authority.js";
 import { FIELD_STALENESS_TICKLER, FIELD_STALENESS_TICKLER_CLI_ALIAS, inspectStalenessTickler, } from "./staleness-tickler.js";
@@ -12,16 +14,21 @@ export * from "./capacity.js";
 export * from "./decisions.js";
 export * from "./disclosure.js";
 export * from "./host-hooks.js";
+export * from "./hotfix-criteria.js";
+export * from "./intent-ceiling.js";
+export * from "./no-deft-directive.js";
 export * from "./org-force-on-migration.js";
 export * from "./plan-extensions.js";
 export * from "./policy-invocation.js";
 export * from "./product-signal.js";
+export * from "./require-human-merge.js";
 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 * from "./write-fence.js";
 export const FIELD_ALLOW_DIRECT_COMMITS = "plan.policy.allowDirectCommitsToMaster";
 export const FIELD_WIP_CAP = "plan.policy.wipCap";
 export const FIELD_SESSION_RITUAL_STALENESS_HOURS = "plan.policy.sessionRitualStalenessHours";
@@ -271,6 +278,24 @@ function inspectHostHooksField(data) {
         source: field.source,
     };
 }
+function inspectRequireHumanMergeField(data, projectRoot) {
+    const field = inspectRequireHumanMerge(data, projectRoot);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
+function inspectHotfixCriteriaField(data) {
+    const field = inspectHotfixCriteria(data);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 const REGISTERED_POLICIES = [
     inspectAllowDirectCommits,
     inspectWipCap,
@@ -288,6 +313,8 @@ const REGISTERED_POLICIES = [
     inspectRuntimeAuthorityField,
     inspectProductSignalField,
     inspectValueFeedbackField,
+    inspectRequireHumanMergeField,
+    inspectHotfixCriteriaField,
 ];
 /** Walk registered inspectors and return one row per field (#1148). */
 export function inspectAllPolicies(projectRoot) {
@@ -306,7 +333,11 @@ export function inspectOnePolicy(name, projectRoot) {
                     ? FIELD_RUNTIME_AUTHORITY
                     : name === FIELD_HOST_HOOKS_CLI_ALIAS
                         ? FIELD_HOST_HOOKS
-                        : name;
+                        : name === FIELD_REQUIRE_HUMAN_MERGE_CLI_ALIAS
+                            ? FIELD_REQUIRE_HUMAN_MERGE
+                            : name === FIELD_HOTFIX_CRITERIA_CLI_ALIAS
+                                ? FIELD_HOTFIX_CRITERIA
+                                : name;
     for (const field of inspectAllPolicies(projectRoot)) {
         if (field.name === normalized)
             return field;

package/dist/policy/intent-ceiling.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Slash-command intent containment (#1193 / extends #810).
+ *
+ * When a session inherits a slash command as its verb, that verb is the *only*
+ * authorized intent for the session. Non-implement verbs must not authorize
+ * implement / push / PR / merge / deploy tool paths.
+ *
+ * Provenance: set `DEFT_SESSION_SLASH_VERB` (e.g. `/github-issue`, `github-issue`,
+ * `/build`) for the session, or pass `sessionVerb` explicitly to pure evaluators.
+ */
+/** Env var carrying the session's slash-command verb (#1193). */
+export declare const ENV_SESSION_SLASH_VERB = "DEFT_SESSION_SLASH_VERB";
+/**
+ * Free-text action verbs that authorize implementation under #810.
+ * Parallel list for slash forms lives in IMPLEMENT_SLASH_VERBS.
+ */
+export declare const FREE_TEXT_IMPLEMENT_VERBS: readonly ["build", "implement", "ship", "swarm", "run agents", "start agent"];
+/**
+ * Slash-command stems that authorize implementation (#1193 R1).
+ * Matched after normalizing `/prefix` and `:namespace` forms.
+ */
+export declare const IMPLEMENT_SLASH_VERBS: Set<string>;
+/**
+ * Explicit non-implement slash stems — always contained.
+ * Unknown stems default to non-implement (fail closed for lifecycle escalation).
+ */
+export declare const NON_IMPLEMENT_SLASH_VERBS: Set<string>;
+/** Lifecycle ops gated by the intent ceiling. */
+export declare const INTENT_CEILING_OPS: readonly ["implement", "push", "pr", "merge", "deploy"];
+export type IntentCeilingOp = (typeof INTENT_CEILING_OPS)[number];
+export type IntentCeilingCode = "intent-allow-no-slash" | "intent-allow-implement-verb" | "intent-deny-non-implement" | "intent-deny-unknown-slash";
+export interface IntentCeilingDecision {
+    readonly allowed: boolean;
+    readonly code: IntentCeilingCode;
+    readonly reason: string;
+    /** Normalized slash stem (without leading `/`), or null when no slash provenance. */
+    readonly sessionVerb: string | null;
+    readonly requestedOp: IntentCeilingOp;
+}
+/**
+ * Normalize a slash command or free-text verb to a comparable stem.
+ * `/deft:directive:github-issue` → `github-issue`; `/build` → `build`.
+ */
+export declare function normalizeSessionVerb(raw: string | null | undefined): string | null;
+/** True when the normalized stem authorizes implementation. */
+export declare function isImplementSlashVerb(stem: string | null): boolean;
+/** True when the stem is an explicitly known non-implement command. */
+export declare function isNonImplementSlashVerb(stem: string | null): boolean;
+export interface EvaluateIntentCeilingInput {
+    readonly sessionVerb?: string | null;
+    readonly requestedOp: IntentCeilingOp;
+}
+/**
+ * Pure intent-ceiling evaluator (#1193 R1).
+ *
+ * - No slash verb → allow (free-text #810 action-verb remains agent/AGENTS gate).
+ * - Implement slash verb → allow all lifecycle ops.
+ * - Non-implement / unknown slash verb → deny implement/push/pr/merge/deploy.
+ */
+export declare function evaluateIntentCeiling(input: EvaluateIntentCeilingInput): IntentCeilingDecision;
+/** Read session slash verb from the environment. */
+export declare function readSessionSlashVerbFromEnv(env?: NodeJS.ProcessEnv): string | null;
+/**
+ * Evaluate intent ceiling for a lifecycle op using env-backed session verb.
+ * Convenience for preflight / hooks / merge gates.
+ */
+export declare function evaluateIntentCeilingFromEnv(requestedOp: IntentCeilingOp, env?: NodeJS.ProcessEnv): IntentCeilingDecision;
+/**
+ * Map classifiable shell/MCP lifecycle signals onto intent-ceiling ops.
+ * Returns null when the tool path is not a gated lifecycle op.
+ */
+export declare function intentOpFromShellSignals(signals: {
+    readonly isPush?: boolean;
+    readonly isMerge?: boolean;
+    readonly isPr?: boolean;
+    readonly isDeploy?: boolean;
+    readonly isImplement?: boolean;
+}): IntentCeilingOp | null;
+//# sourceMappingURL=intent-ceiling.d.ts.map

package/dist/policy/intent-ceiling.js

@@ -0,0 +1,181 @@
+/**
+ * Slash-command intent containment (#1193 / extends #810).
+ *
+ * When a session inherits a slash command as its verb, that verb is the *only*
+ * authorized intent for the session. Non-implement verbs must not authorize
+ * implement / push / PR / merge / deploy tool paths.
+ *
+ * Provenance: set `DEFT_SESSION_SLASH_VERB` (e.g. `/github-issue`, `github-issue`,
+ * `/build`) for the session, or pass `sessionVerb` explicitly to pure evaluators.
+ */
+/** Env var carrying the session's slash-command verb (#1193). */
+export const ENV_SESSION_SLASH_VERB = "DEFT_SESSION_SLASH_VERB";
+/**
+ * Free-text action verbs that authorize implementation under #810.
+ * Parallel list for slash forms lives in IMPLEMENT_SLASH_VERBS.
+ */
+export const FREE_TEXT_IMPLEMENT_VERBS = [
+    "build",
+    "implement",
+    "ship",
+    "swarm",
+    "run agents",
+    "start agent",
+];
+/**
+ * Slash-command stems that authorize implementation (#1193 R1).
+ * Matched after normalizing `/prefix` and `:namespace` forms.
+ */
+export const IMPLEMENT_SLASH_VERBS = new Set([
+    "build",
+    "implement",
+    "ship",
+    "ship-hotfix",
+    "swarm",
+    "start-agent",
+    "start_agent",
+    "run-agents",
+    "run_agents",
+]);
+/**
+ * Explicit non-implement slash stems — always contained.
+ * Unknown stems default to non-implement (fail closed for lifecycle escalation).
+ */
+export const NON_IMPLEMENT_SLASH_VERBS = new Set([
+    "github-issue",
+    "github_issue",
+    "issue",
+    "triage",
+    "refine",
+    "refinement",
+    "discuss",
+    "research",
+    "probe",
+    "glossary",
+    "sync",
+    "continue",
+    "checkpoint",
+    "feedback",
+    "article-review",
+    "cost",
+    "setup",
+    "interview",
+    "map",
+    "yolo",
+    "speckit",
+    "change",
+]);
+/** Lifecycle ops gated by the intent ceiling. */
+export const INTENT_CEILING_OPS = ["implement", "push", "pr", "merge", "deploy"];
+/**
+ * Normalize a slash command or free-text verb to a comparable stem.
+ * `/deft:directive:github-issue` → `github-issue`; `/build` → `build`.
+ */
+export function normalizeSessionVerb(raw) {
+    if (raw === null || raw === undefined)
+        return null;
+    let s = raw.trim().toLowerCase();
+    if (s.length === 0)
+        return null;
+    // Strip leading slashes.
+    while (s.startsWith("/"))
+        s = s.slice(1);
+    // Drop product namespaces: deft:directive:github-issue → github-issue
+    if (s.includes(":")) {
+        const parts = s.split(":").filter((p) => p.length > 0);
+        s = parts[parts.length - 1] ?? s;
+    }
+    // Normalize underscores to hyphens for allowlist matching.
+    s = s.replace(/_/g, "-");
+    return s.length > 0 ? s : null;
+}
+/** True when the normalized stem authorizes implementation. */
+export function isImplementSlashVerb(stem) {
+    if (stem === null)
+        return false;
+    if (IMPLEMENT_SLASH_VERBS.has(stem))
+        return true;
+    // Free-text multi-word forms already hyphenated by normalize (run agents → not here).
+    return false;
+}
+/** True when the stem is an explicitly known non-implement command. */
+export function isNonImplementSlashVerb(stem) {
+    if (stem === null)
+        return false;
+    return NON_IMPLEMENT_SLASH_VERBS.has(stem);
+}
+/**
+ * Pure intent-ceiling evaluator (#1193 R1).
+ *
+ * - No slash verb → allow (free-text #810 action-verb remains agent/AGENTS gate).
+ * - Implement slash verb → allow all lifecycle ops.
+ * - Non-implement / unknown slash verb → deny implement/push/pr/merge/deploy.
+ */
+export function evaluateIntentCeiling(input) {
+    const stem = normalizeSessionVerb(input.sessionVerb ?? null);
+    const op = input.requestedOp;
+    if (stem === null) {
+        return {
+            allowed: true,
+            code: "intent-allow-no-slash",
+            reason: "No slash-command session verb; free-text #810 action-verb rules apply.",
+            sessionVerb: null,
+            requestedOp: op,
+        };
+    }
+    if (isImplementSlashVerb(stem)) {
+        return {
+            allowed: true,
+            code: "intent-allow-implement-verb",
+            reason: `Slash verb '/${stem}' authorizes implementation lifecycle ops.`,
+            sessionVerb: stem,
+            requestedOp: op,
+        };
+    }
+    const knownNon = isNonImplementSlashVerb(stem);
+    const code = knownNon
+        ? "intent-deny-non-implement"
+        : "intent-deny-unknown-slash";
+    return {
+        allowed: false,
+        code,
+        reason: `Slash-command intent ceiling (#1193): session verb '/${stem}' does not authorize ` +
+            `${op}. Non-implement verbs terminate at their named outcome; file a follow-up issue ` +
+            `instead of escalating to implement/push/PR/merge/deploy. ` +
+            `Implement verbs: /build, /ship, /ship-hotfix, /swarm, /implement.`,
+        sessionVerb: stem,
+        requestedOp: op,
+    };
+}
+/** Read session slash verb from the environment. */
+export function readSessionSlashVerbFromEnv(env = process.env) {
+    return normalizeSessionVerb(env[ENV_SESSION_SLASH_VERB] ?? null);
+}
+/**
+ * Evaluate intent ceiling for a lifecycle op using env-backed session verb.
+ * Convenience for preflight / hooks / merge gates.
+ */
+export function evaluateIntentCeilingFromEnv(requestedOp, env = process.env) {
+    return evaluateIntentCeiling({
+        sessionVerb: readSessionSlashVerbFromEnv(env),
+        requestedOp,
+    });
+}
+/**
+ * Map classifiable shell/MCP lifecycle signals onto intent-ceiling ops.
+ * Returns null when the tool path is not a gated lifecycle op.
+ */
+export function intentOpFromShellSignals(signals) {
+    if (signals.isDeploy)
+        return "deploy";
+    if (signals.isMerge)
+        return "merge";
+    if (signals.isPr)
+        return "pr";
+    if (signals.isPush)
+        return "push";
+    if (signals.isImplement)
+        return "implement";
+    return null;
+}
+//# sourceMappingURL=intent-ceiling.js.map

package/dist/policy/no-deft-directive.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Official per-project opt-out flag for Directive (#2926).
+ *
+ * Presence of root `.no-deft-directive` means this project does not use
+ * Directive. Session ritual, doctor setup pressure, init/update install paths,
+ * and setup skills must honor the flag. Empty file or a short comment is enough.
+ *
+ * Product choices (v1):
+ * - Flag is **root-only** (workspace root the tool opened). Nested monorepo
+ *   package roots are a documented follow-up.
+ * - Flag **wins locally** over ambient trusted-org / product-signal force-on.
+ * - Flag + deposit (`.deft/core`) is **inconsistent**: doctor **warns**;
+ *   mutating install/update paths **fail closed**.
+ * - Creating the flag does **not** delete an existing deposit.
+ */
+/** Canonical root-only filename (lowercase). Presence = flag. */
+export declare const NO_DEFT_DIRECTIVE_FLAG_NAME = ".no-deft-directive";
+/** One-line operator message when Directive is disabled by the flag. */
+export declare const NO_DEFT_DIRECTIVE_DISABLED_MESSAGE = "Directive disabled via `.no-deft-directive`";
+/**
+ * Loud diagnosis when both the opt-out flag and a deposit exist.
+ * Product choice (#2926): doctor **warns**; install/update **fail closed**.
+ */
+export declare const NO_DEFT_DIRECTIVE_INCONSISTENT_MESSAGE = "Inconsistent state: `.no-deft-directive` is present but a Directive deposit (`.deft/core`) also exists. Remove the flag to use Directive, or remove the deposit if opt-out is intentional.";
+/** Recorded product choice for inconsistent flag+deposit handling. */
+export declare const NO_DEFT_DIRECTIVE_INCONSISTENT_POLICY: "warn-and-fail-closed";
+export interface NoDeftDirectiveSeams {
+    readonly isFile?: (path: string) => boolean;
+    readonly isDir?: (path: string) => boolean;
+}
+export interface NoDeftDirectiveState {
+    readonly present: boolean;
+    readonly flagPath: string;
+    readonly depositPresent: boolean;
+    /** True when flag and deposit are both present. */
+    readonly inconsistent: boolean;
+}
+/** Absolute path to the root flag file. */
+export declare function noDeftDirectiveFlagPath(projectRoot: string): string;
+/**
+ * Detect root `.no-deft-directive` and whether a deposit is also present.
+ * Presence is file-existence only (empty or short comment OK).
+ */
+export declare function detectNoDeftDirective(projectRoot: string, seams?: NoDeftDirectiveSeams): NoDeftDirectiveState;
+/** True when the root opt-out flag file exists. */
+export declare function isNoDeftDirectivePresent(projectRoot: string, seams?: NoDeftDirectiveSeams): boolean;
+/**
+ * Create the root opt-out flag. Optional one-line rationale becomes a `#` comment.
+ * Does not remove an existing deposit.
+ */
+export declare function createNoDeftDirectiveFlag(projectRoot: string, options?: {
+    rationale?: string;
+}): string;
+/**
+ * Remove the root opt-out flag when present.
+ * @returns true when a file was removed.
+ */
+export declare function removeNoDeftDirectiveFlag(projectRoot: string): boolean;
+//# sourceMappingURL=no-deft-directive.d.ts.map

package/dist/policy/no-deft-directive.js

@@ -0,0 +1,110 @@
+/**
+ * Official per-project opt-out flag for Directive (#2926).
+ *
+ * Presence of root `.no-deft-directive` means this project does not use
+ * Directive. Session ritual, doctor setup pressure, init/update install paths,
+ * and setup skills must honor the flag. Empty file or a short comment is enough.
+ *
+ * Product choices (v1):
+ * - Flag is **root-only** (workspace root the tool opened). Nested monorepo
+ *   package roots are a documented follow-up.
+ * - Flag **wins locally** over ambient trusted-org / product-signal force-on.
+ * - Flag + deposit (`.deft/core`) is **inconsistent**: doctor **warns**;
+ *   mutating install/update paths **fail closed**.
+ * - Creating the flag does **not** delete an existing deposit.
+ */
+import { existsSync, statSync, unlinkSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
+import { assertWriteTargetSafe } from "../fs/projection-containment.js";
+import { CANONICAL_INSTALL_ROOT } from "../init-deposit/constants.js";
+/** Canonical root-only filename (lowercase). Presence = flag. */
+export const NO_DEFT_DIRECTIVE_FLAG_NAME = ".no-deft-directive";
+/** One-line operator message when Directive is disabled by the flag. */
+export const NO_DEFT_DIRECTIVE_DISABLED_MESSAGE = "Directive disabled via `.no-deft-directive`";
+/**
+ * Loud diagnosis when both the opt-out flag and a deposit exist.
+ * Product choice (#2926): doctor **warns**; install/update **fail closed**.
+ */
+export const NO_DEFT_DIRECTIVE_INCONSISTENT_MESSAGE = "Inconsistent state: `.no-deft-directive` is present but a Directive deposit (`.deft/core`) also exists. Remove the flag to use Directive, or remove the deposit if opt-out is intentional.";
+/** Recorded product choice for inconsistent flag+deposit handling. */
+export const NO_DEFT_DIRECTIVE_INCONSISTENT_POLICY = "warn-and-fail-closed";
+function defaultIsFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function defaultIsDir(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Absolute path to the root flag file. */
+export function noDeftDirectiveFlagPath(projectRoot) {
+    return resolve(projectRoot, NO_DEFT_DIRECTIVE_FLAG_NAME);
+}
+/**
+ * Detect root `.no-deft-directive` and whether a deposit is also present.
+ * Presence is file-existence only (empty or short comment OK).
+ */
+export function detectNoDeftDirective(projectRoot, seams = {}) {
+    const flagPath = noDeftDirectiveFlagPath(projectRoot);
+    const isFile = seams.isFile ?? defaultIsFile;
+    const isDir = seams.isDir ?? defaultIsDir;
+    const present = isFile(flagPath);
+    const depositPresent = isDir(join(projectRoot, CANONICAL_INSTALL_ROOT));
+    return {
+        present,
+        flagPath,
+        depositPresent,
+        inconsistent: present && depositPresent,
+    };
+}
+/** True when the root opt-out flag file exists. */
+export function isNoDeftDirectivePresent(projectRoot, seams = {}) {
+    return detectNoDeftDirective(projectRoot, seams).present;
+}
+/**
+ * Create the root opt-out flag. Optional one-line rationale becomes a `#` comment.
+ * Does not remove an existing deposit.
+ */
+export function createNoDeftDirectiveFlag(projectRoot, options = {}) {
+    const path = noDeftDirectiveFlagPath(projectRoot);
+    if (defaultIsDir(path)) {
+        throw new Error(`${NO_DEFT_DIRECTIVE_FLAG_NAME} exists as a directory at ${path}; remove it before creating the opt-out flag file.`);
+    }
+    const rationale = options.rationale?.trim() ?? "";
+    const body = rationale.length > 0 ? `# ${rationale}\n` : "";
+    // #2951: product write sinks route through containedWrite (create|replace).
+    // Use replace so re-running with a new rationale updates the flag file.
+    containedWrite({
+        root: resolve(projectRoot),
+        target: path,
+        data: body,
+        mode: "replace",
+    });
+    return path;
+}
+/**
+ * Remove the root opt-out flag when present.
+ * @returns true when a file was removed.
+ */
+export function removeNoDeftDirectiveFlag(projectRoot) {
+    const path = noDeftDirectiveFlagPath(projectRoot);
+    if (!existsSync(path)) {
+        return false;
+    }
+    assertWriteTargetSafe(projectRoot, path);
+    if (defaultIsDir(path)) {
+        throw new Error(`${NO_DEFT_DIRECTIVE_FLAG_NAME} exists as a directory at ${path}; remove the directory manually before enabling Directive.`);
+    }
+    unlinkSync(path);
+    return true;
+}
+//# sourceMappingURL=no-deft-directive.js.map

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

@@ -9,6 +9,10 @@ export interface OrgForceOnMarker {
     readonly valueFeedback: boolean;
     readonly productSignal: boolean;
     readonly directiveVersion: string;
+    /** Pre-apply typed valueFeedback snapshot for verify-on-skip (#2903). */
+    readonly previousValueFeedback?: unknown;
+    /** Pre-apply typed productSignal snapshot for verify-on-skip (#2903). */
+    readonly previousProductSignal?: unknown;
 }
 /** Canonical typed block written by the one-time migration (#2822 Part A). */
 export declare const FORCE_ON_VALUE_FEEDBACK_BLOCK: {
@@ -17,8 +21,51 @@ export declare const FORCE_ON_VALUE_FEEDBACK_BLOCK: {
     readonly sessionLine: true;
     readonly upstreamPrompt: false;
 };
+/** Normalize undefined → null and deep-sort keys so marker snapshots compare stably. */
+export declare function normalizePolicySnapshot(raw: unknown): unknown;
+/**
+ * Structural equality for policy snapshots (#2903).
+ * Key order independent via sortKeysDeep — discarded-PD recovery must not miss
+ * semantically equal blocks written with different JSON key order.
+ */
+export declare function deepEqualPolicySnapshot(a: unknown, b: unknown): boolean;
 /** Read the #2822 migration marker when present and valid. */
 export declare function readOrgForceOnMarker(projectRoot: string): OrgForceOnMarker | null;
+/**
+ * Sentinel previous* for an unforced field that had no stored baseline (legacy
+ * partial recovery). Must not deep-equal any real policy snapshot — including
+ * null/undefined after clear-value-feedback — or the next update would re-force.
+ */
+export declare const ORG_FORCE_ON_NO_BASELINE: {
+    readonly "x-directive/org-force-on": "no-baseline";
+};
+/** Classic #2822 pre-migration all-false valueFeedback baseline (statusreport). */
+export declare const PRE_MIGRATION_VALUE_FEEDBACK_BASELINE: {
+    readonly enabled: false;
+    readonly emitEvents: false;
+    readonly sessionLine: false;
+    readonly upstreamPrompt: false;
+};
+/** True when current VF looks like discarded pre-migration state (legacy markers). */
+export declare function looksLikePreMigrationValueFeedback(raw: unknown): boolean;
+/** True when current PS looks like discarded pre-migration state (legacy markers). */
+export declare function looksLikePreMigrationProductSignal(raw: unknown): boolean;
+/**
+ * Incomplete migration (#2903): marker present, PD still needs force-on, and
+ * current typed block still equals the pre-migration snapshot (or legacy marker
+ * has no previous* field and current still looks like the classic baseline).
+ *
+ * Exact restore of the pre-migration snapshot is treated as incomplete by design
+ * (company policy #2376 / #2822 / #2903): discarded working-tree force-on and
+ * "put the old all-false block back" are not distinguishable without git history,
+ * and trusted-org local collection should stay ON. True intentional opt-out must
+ * use a shape that differs from previous*, `policy:clear-value-feedback`, or
+ * root `.no-deft-directive`. Outbound product-signal still requires D17 consent.
+ *
+ * Legacy markers without previous*: only re-apply fields that still look like the
+ * classic pre-migration baseline so a distinct intentional sibling opt-out is kept.
+ */
+export declare function isIncompleteForceOnField(needsForceOn: boolean, current: unknown, previousSnapshot: unknown | undefined, previousFieldPresent: boolean, field?: "valueFeedback" | "productSignal"): boolean;
 export interface RunOrgForceOnMigrationOptions {
     readonly autoEnable?: OrgAutoEnableOptions;
     readonly actor?: string;
@@ -33,6 +80,11 @@ export interface OrgForceOnMigrationResult {
 /**
  * One-time trusted-org install/upgrade force-on for valueFeedback + productSignal
  * (#2822). Idempotent via durable marker; non-trusted orgs are unchanged.
+ *
+ * #2903 verify-on-skip: when the marker is present but PROJECT-DEFINITION still
+ * matches the pre-migration snapshot (discarded / never-landed force-on write),
+ * re-apply. Intentional post-migration shapes that differ from both the previous
+ * snapshot and the force-on block keep the skip.
  */
 export declare function runOrgForceOnMigration(projectRoot: string, options?: RunOrgForceOnMigrationOptions): OrgForceOnMigrationResult;
 /** True when typed valueFeedback matches the #2822 force-on block shape. */