@deftai/directive-core 0.101.0 → 0.103.0

package/dist/policy/coverage-debt.js

@@ -1,34 +1,26 @@
 /**
- * Coverage-debt hatch policy (#3189).
+ * Coverage-debt hatch policy (#3189 / #3314).
  *
- * Consent / SoT surface for consumer expansion of release-originated hatch
- * behavior (#3187). Unset is fail-closed for behavior (mode off) but still
- * nags on interactive session-start until decided or dismissed with reason.
- *
- * Non-goal: a consumer tree never auto-files coverage-debt issues on
- * deftai/directive -- ledger is always THIS repo.
+ * Plain optional setting. Default off. Fail-closed when absent or invalid.
+ * Hatch / auto-file are reserved — not a ship gate. Live hatch is
+ * `--allow-coverage-debt=#N` (#2866).
  */
-import { readFileSync } from "node:fs";
-import { atomicWriteProjectDefinition, projectDefinitionMutationLock, } from "../vbrief-build/project-definition-io.js";
-import { migrateLegacyPolicyKey, PLAN_POLICY_KEY, readPlanPolicy } from "./plan-extensions.js";
-import { policyColonInvocation } from "./policy-invocation.js";
-import { appendAuditLog, loadProjectDefinition, projectDefinitionPath } from "./resolve.js";
+import { resolveCheckResume } from "./check-resume.js";
+import { readPlanPolicy } from "./plan-extensions.js";
+import { loadProjectDefinition } from "./resolve.js";
 /** Canonical registered policy field name. */
 export const FIELD_COVERAGE_DEBT = "plan.policy.coverageDebt";
 /** Short alias for `policy:show --field=coverageDebt`. */
 export const FIELD_COVERAGE_DEBT_CLI_ALIAS = "coverageDebt";
-export const COVERAGE_DEBT_STATUSES = ["unset", "decided"];
 export const COVERAGE_DEBT_MODES = ["off", "warn", "hatch"];
-/** Fail-closed effective mode when unset / missing / invalid. */
+/** Fail-closed effective mode when absent / missing / invalid. */
 export const DEFAULT_COVERAGE_DEBT_MODE = "off";
 /** Consumers default autoFile false even under hatch mode. */
 export const DEFAULT_COVERAGE_DEBT_AUTO_FILE = false;
 function defaultResolved(source, error = null) {
     return {
-        status: "unset",
         mode: DEFAULT_COVERAGE_DEBT_MODE,
         autoFile: DEFAULT_COVERAGE_DEBT_AUTO_FILE,
-        dismissReason: null,
         source,
         error,
     };
@@ -36,10 +28,7 @@ function defaultResolved(source, error = null) {
 function isMode(value) {
     return typeof value === "string" && COVERAGE_DEBT_MODES.includes(value);
 }
-function isStatus(value) {
-    return typeof value === "string" && COVERAGE_DEBT_STATUSES.includes(value);
-}
-/** Validate a `plan.policy.coverageDebt` payload. */
+/** Validate a `plan.policy.coverageDebt` payload. Extra keys are ignored. */
 export function validateCoverageDebt(value) {
     if (value === null || value === undefined) {
         return [];
@@ -49,25 +38,17 @@ export function validateCoverageDebt(value) {
     }
     const rec = value;
     const errors = [];
-    if ("status" in rec && !isStatus(rec.status)) {
-        errors.push(`${FIELD_COVERAGE_DEBT}.status must be one of ${COVERAGE_DEBT_STATUSES.join("|")}`);
-    }
     if ("mode" in rec && !isMode(rec.mode)) {
         errors.push(`${FIELD_COVERAGE_DEBT}.mode must be one of ${COVERAGE_DEBT_MODES.join("|")}`);
     }
     if ("autoFile" in rec && typeof rec.autoFile !== "boolean") {
         errors.push(`${FIELD_COVERAGE_DEBT}.autoFile must be a boolean`);
     }
-    if ("dismissReason" in rec &&
-        rec.dismissReason !== null &&
-        typeof rec.dismissReason !== "string") {
-        errors.push(`${FIELD_COVERAGE_DEBT}.dismissReason must be a string or null`);
-    }
     return errors;
 }
 /**
- * Resolve a typed block. Missing/invalid → fail-closed mode off, status unset.
- * Unset is not the same as decided-off for nag purposes.
+ * Resolve a typed block. Missing/invalid → fail-closed mode off.
+ * `mode` is the setting; leftover ritual fields (status/dismissReason) are ignored.
  */
 export function resolveCoverageDebtFromTypedBlock(raw) {
     const errors = validateCoverageDebt(raw);
@@ -78,26 +59,17 @@ export function resolveCoverageDebtFromTypedBlock(raw) {
         return defaultResolved("default");
     }
     const block = raw;
-    const status = isStatus(block.status) ? block.status : "unset";
     const mode = isMode(block.mode) ? block.mode : DEFAULT_COVERAGE_DEBT_MODE;
-    // Fail-closed: hatch modes only apply when decided.
-    const effectiveMode = status === "decided" ? mode : DEFAULT_COVERAGE_DEBT_MODE;
     const autoFileRaw = typeof block.autoFile === "boolean" ? block.autoFile : DEFAULT_COVERAGE_DEBT_AUTO_FILE;
-    // autoFile only meaningful under hatch; never on when not hatch.
-    const autoFile = effectiveMode === "hatch" ? autoFileRaw : false;
-    const dismissReason = typeof block.dismissReason === "string" && block.dismissReason.trim().length > 0
-        ? block.dismissReason.trim()
-        : null;
+    const autoFile = mode === "hatch" ? autoFileRaw : false;
     return {
-        status,
-        mode: status === "decided" ? mode : DEFAULT_COVERAGE_DEBT_MODE,
+        mode,
         autoFile,
-        dismissReason: status === "decided" ? dismissReason : null,
         source: "typed",
         error: null,
     };
 }
-/** Resolve `plan.policy.coverageDebt` from PROJECT-DEFINITION (#3189). */
+/** Resolve `plan.policy.coverageDebt` from PROJECT-DEFINITION (#3314). */
 export function resolveCoverageDebt(projectRoot) {
     const [data, err] = loadProjectDefinition(projectRoot);
     if (data === null) {
@@ -112,40 +84,28 @@ export function resolveCoverageDebt(projectRoot) {
     }
     return resolveCoverageDebtFromTypedBlock(policyBlock.coverageDebt);
 }
-/** Effective hatch soft-pass allowed only when decided mode=hatch. */
+/** Effective hatch soft-pass allowed only when mode=hatch. Reserved — unused by check/release. */
 export function isCoverageDebtHatchAllowed(policy) {
-    return policy.status === "decided" && policy.mode === "hatch";
+    return policy.mode === "hatch";
 }
 /** Auto-file debt issues only when hatch is allowed AND autoFile true. */
 export function isCoverageDebtAutoFileAllowed(policy) {
     return isCoverageDebtHatchAllowed(policy) && policy.autoFile === true;
 }
-/**
- * Non-goal guard (#3189): consumer trees never auto-file coverage-debt on
- * deftai/directive. Ledger is always the project under check.
- */
-export function coverageDebtLedgerRepoIsSelfOnly() {
-    return true;
-}
 export function formatCoverageDebtStatusLine(policy) {
-    const dismiss = policy.dismissReason !== null ? ` dismissReason=${JSON.stringify(policy.dismissReason)}` : "";
-    return (`[deft policy] coverageDebt status=${policy.status} mode=${policy.mode} ` +
-        `autoFile=${String(policy.autoFile)}${dismiss} (source=${policy.source}).`);
+    return (`[deft policy] coverageDebt mode=${policy.mode} ` +
+        `autoFile=${String(policy.autoFile)} (source=${policy.source}).`);
 }
 function fieldFromResolved(resolved) {
     return {
         name: FIELD_COVERAGE_DEBT,
         current: {
-            status: resolved.status,
             mode: resolved.mode,
             autoFile: resolved.autoFile,
-            dismissReason: resolved.dismissReason,
         },
         default: {
-            status: "unset",
             mode: DEFAULT_COVERAGE_DEBT_MODE,
             autoFile: DEFAULT_COVERAGE_DEBT_AUTO_FILE,
-            dismissReason: null,
         },
         source: resolved.source,
     };
@@ -167,96 +127,27 @@ export function inspectCoverageDebt(data, projectRoot) {
     }
     return fieldFromResolved(resolveCoverageDebtFromTypedBlock(policyBlock.coverageDebt));
 }
-/** Persist decided coverageDebt (preset or dismiss-with-reason). */
-export function writeCoverageDebt(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)) {
-                if (data.plan === undefined) {
-                    data.plan = {};
-                }
-                else {
-                    throw new Error("PROJECT-DEFINITION 'plan' is not an object");
-                }
-            }
-            const plan = data.plan;
-            migrateLegacyPolicyKey(plan);
-            const existingPolicy = plan[PLAN_POLICY_KEY];
-            if (typeof existingPolicy !== "object" ||
-                existingPolicy === null ||
-                Array.isArray(existingPolicy)) {
-                if (existingPolicy === undefined) {
-                    plan[PLAN_POLICY_KEY] = {};
-                }
-                else {
-                    throw new Error("plan.policy is not an object");
-                }
-            }
-            const policyBlock = plan[PLAN_POLICY_KEY];
-            const previous = policyBlock.coverageDebt;
-            const autoFile = options.mode === "hatch" ? (options.autoFile ?? DEFAULT_COVERAGE_DEBT_AUTO_FILE) : false;
-            const dismissReason = typeof options.dismissReason === "string" && options.dismissReason.trim().length > 0
-                ? options.dismissReason.trim()
-                : null;
-            const nextBlock = {
-                status: "decided",
-                mode: options.mode,
-                autoFile,
-                dismissReason,
-            };
-            const previousNormalized = resolveCoverageDebtFromTypedBlock(previous);
-            const changedFlag = previousNormalized.status !== nextBlock.status ||
-                previousNormalized.mode !== nextBlock.mode ||
-                previousNormalized.autoFile !== nextBlock.autoFile ||
-                previousNormalized.dismissReason !== nextBlock.dismissReason;
-            policyBlock.coverageDebt = nextBlock;
-            if (changedFlag) {
-                atomicWriteProjectDefinition(path, data);
-            }
-            const actor = options.actor ?? policyColonInvocation("set-coverage-debt");
-            const note = options.note ?? "";
-            const parts = [
-                `actor=${actor}`,
-                "coverageDebt.status=decided",
-                `mode=${nextBlock.mode}`,
-                `autoFile=${String(nextBlock.autoFile)}`,
-                `dismissReason=${JSON.stringify(nextBlock.dismissReason)}`,
-                `previous=${JSON.stringify(previous ?? null)}`,
-            ];
-            if (note) {
-                parts.push(`note=${note.replace(/\n/g, " ").replace(/\r/g, " ")}`);
-            }
-            appendAuditLog(projectRoot, parts.join(" "));
-            return { changed: changedFlag };
-        });
-        const resolved = resolveCoverageDebt(projectRoot);
-        const lines = [
-            `\u2713 ${FIELD_COVERAGE_DEBT} status=decided mode=${resolved.mode}.`,
-            changed
-                ? "  audit: meta/policy-changes.log updated."
-                : "  no-op: value already matched (audit entry still appended for trail).",
-            formatCoverageDebtStatusLine(resolved),
-        ];
-        return { exitCode: 0, stdout: `${lines.join("\n")}\n`, changed };
+/**
+ * One-line standing disclosure when either setting is non-default (#3314).
+ * Silent when both default / invalid (invalid is fail-closed off).
+ */
+export function coverageCheckResumeDisclosureLine(debt, resume) {
+    const debtNonDefault = debt.source !== "default-on-error" && debt.mode !== DEFAULT_COVERAGE_DEBT_MODE;
+    const resumeNonDefault = resume.source !== "default-on-error" && resume.localStamp === "on";
+    if (!debtNonDefault && !resumeNonDefault) {
+        return null;
     }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        if (message.includes("PROJECT-DEFINITION not found") ||
-            message.includes("ENOENT") ||
-            message.includes("no such file")) {
-            return {
-                exitCode: 2,
-                stdout: `\u274c PROJECT-DEFINITION not found under ${projectRoot}\n`,
-                changed: false,
-            };
-        }
-        return { exitCode: 2, stdout: `\u274c Config error: ${message}\n`, changed: false };
+    const parts = [];
+    if (debtNonDefault) {
+        parts.push(`coverageDebt.mode=${debt.mode}`);
+    }
+    if (resumeNonDefault) {
+        parts.push("checkResume.localStamp=on");
     }
+    return `[deft policy] ${parts.join(" ")} (reserved; not a ship gate).`;
+}
+/** Resolve both settings and format the standing disclosure, or null. */
+export function maybeFormatCoverageCheckResumeDisclosure(projectRoot) {
+    return coverageCheckResumeDisclosureLine(resolveCoverageDebt(projectRoot), resolveCheckResume(projectRoot));
 }
 //# sourceMappingURL=coverage-debt.js.map

package/dist/policy/index.d.ts

@@ -3,8 +3,8 @@ export * from "./agents-md-advisory.js";
 export * from "./autonomy.js";
 export * from "./capacity.js";
 export * from "./ceremony-dial.js";
+export * from "./ceremony-dial-escalation.js";
 export * from "./check-resume.js";
-export * from "./coverage-check-resume-presets.js";
 export * from "./coverage-debt.js";
 export * from "./decisions.js";
 export * from "./deft-directive-disable.js";

package/dist/policy/index.js

@@ -22,8 +22,8 @@ export * from "./agents-md-advisory.js";
 export * from "./autonomy.js";
 export * from "./capacity.js";
 export * from "./ceremony-dial.js";
+export * from "./ceremony-dial-escalation.js";
 export * from "./check-resume.js";
-export * from "./coverage-check-resume-presets.js";
 export * from "./coverage-debt.js";
 export * from "./decisions.js";
 export * from "./deft-directive-disable.js";

package/dist/product-first-done-gate/acceptance.js

@@ -5,6 +5,7 @@
  * Interoperates with #3267 plan.metadata.literal_acceptance_commands.
  */
 import { attachLiteralAcceptanceCommands, readStoredLiteralAcceptanceCommands, } from "../literal-acceptance/index.js";
+import { readAcceptanceClauses, serializeAcceptanceClauses } from "../verify-ac/clauses.js";
 import { PLAN_ACCEPTANCE_KEY, } from "./types.js";
 function asRecord(value) {
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
@@ -73,6 +74,22 @@ export function validatePlanAcceptance(value) {
     if ("source_rung" in rec && rec.source_rung !== undefined && !isAcSourceRung(rec.source_rung)) {
         errors.push('plan.acceptance.source_rung must be "stated" | "derived" | "project_floor"');
     }
+    if ("clauses" in rec && rec.clauses !== undefined && !Array.isArray(rec.clauses)) {
+        errors.push("plan.acceptance.clauses must be an array");
+    }
+    if (Array.isArray(rec.clauses)) {
+        rec.clauses.forEach((entry, index) => {
+            const row = asRecord(entry);
+            if (row === null) {
+                errors.push(`plan.acceptance.clauses[${index}] must be an object`);
+                return;
+            }
+            const text = isNonEmptyString(row.text) ? row.text.trim() : "";
+            if (text.length === 0) {
+                errors.push(`plan.acceptance.clauses[${index}].text must be a non-empty string`);
+            }
+        });
+    }
     const commands = coerceCommands(rec.commands);
     const noneStated = rec.none_stated === true;
     if (commands.length === 0 && !noneStated) {
@@ -110,6 +127,7 @@ export function readPlanAcceptance(plan) {
             if (noneStated && commands.length === 0) {
                 sourceRung = isAcSourceRung(rec.source_rung) ? rec.source_rung : "project_floor";
             }
+            const clauses = readAcceptanceClauses(rec);
             return {
                 commands,
                 none_stated: noneStated,
@@ -119,6 +137,7 @@ export function readPlanAcceptance(plan) {
                     : isNonEmptyString(rec.derivedReason)
                         ? rec.derivedReason
                         : null,
+                ...(clauses.length > 0 ? { clauses } : {}),
             };
         }
     }
@@ -181,6 +200,9 @@ export function attachPlanAcceptance(plan, acceptance) {
     if (acceptance.derived_reason) {
         serializable.derived_reason = acceptance.derived_reason;
     }
+    if (acceptance.clauses !== undefined && acceptance.clauses.length > 0) {
+        serializable.clauses = serializeAcceptanceClauses(acceptance.clauses);
+    }
     let next = {
         ...plan,
         [PLAN_ACCEPTANCE_KEY]: serializable,

package/dist/product-first-done-gate/empty-resolution.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Empty verify:ac resolution is not a green run when there is no suite floor (#3334).
+ *
+ * Framework source keeps today's floor-pass (suite gates own the floor).
+ * Consumer / no-suite projects fail closed with a distinct soft_empty outcome.
+ */
+import type { PlanAcceptance } from "./types.js";
+export declare const EMPTY_AC_OUTCOME: "soft_empty";
+export declare const EMPTY_AC_CAUSE = "no acceptance stamped \u2014 floor is empty in this project";
+export declare const EMPTY_AC_REMEDY = "stamp plan.acceptance (author commands or run intake capture / task issue:ingest)";
+export type VerifyAcResolution = "verified-pass" | "empty-pass" | "soft_empty" | "fail" | "config" | "skipped";
+/** True when this project check composition includes a suite gate (#3188). */
+export declare function projectHasSuiteFloor(projectRoot: string): boolean;
+export declare function isSoftEmptyAcText(text: string): boolean;
+export interface EmptyAcResolutionInput {
+    readonly ok: boolean;
+    readonly code: number;
+    readonly runsLength: number;
+    readonly commandCount: number;
+    readonly rejectedCount: number;
+    readonly resolution?: VerifyAcResolution;
+}
+/** Zero executable commands, no rejected/unpromoted ledger, not already classified. */
+export declare function isEmptyAcResolution(input: EmptyAcResolutionInput): boolean;
+export declare function formatSoftEmptyMessage(acceptance: PlanAcceptance, quiet?: boolean): string;
+//# sourceMappingURL=empty-resolution.d.ts.map

package/dist/product-first-done-gate/empty-resolution.js

@@ -0,0 +1,38 @@
+/**
+ * Empty verify:ac resolution is not a green run when there is no suite floor (#3334).
+ *
+ * Framework source keeps today's floor-pass (suite gates own the floor).
+ * Consumer / no-suite projects fail closed with a distinct soft_empty outcome.
+ */
+import { isFrameworkRepoRoot } from "../check/context.js";
+export const EMPTY_AC_OUTCOME = "soft_empty";
+export const EMPTY_AC_CAUSE = "no acceptance stamped — floor is empty in this project";
+export const EMPTY_AC_REMEDY = "stamp plan.acceptance (author commands or run intake capture / task issue:ingest)";
+/** True when this project check composition includes a suite gate (#3188). */
+export function projectHasSuiteFloor(projectRoot) {
+    return isFrameworkRepoRoot(projectRoot);
+}
+export function isSoftEmptyAcText(text) {
+    return /soft_empty\s*\(#3334\)/i.test(text);
+}
+/** Zero executable commands, no rejected/unpromoted ledger, not already classified. */
+export function isEmptyAcResolution(input) {
+    if (input.resolution === "config" || input.resolution === "skipped") {
+        return false;
+    }
+    if (input.code === 2) {
+        return false;
+    }
+    if (input.rejectedCount > 0 || input.commandCount > 0 || input.runsLength > 0) {
+        return false;
+    }
+    return true;
+}
+export function formatSoftEmptyMessage(acceptance, quiet) {
+    if (quiet) {
+        return "";
+    }
+    return (`verify:ac ${EMPTY_AC_OUTCOME} (#3334) [rung=${acceptance.source_rung}]: ` +
+        `${EMPTY_AC_CAUSE}. ${EMPTY_AC_REMEDY}.`);
+}
+//# sourceMappingURL=empty-resolution.js.map

package/dist/product-first-done-gate/evaluate.d.ts

@@ -3,15 +3,22 @@
  *
  * Runs plan.acceptance.commands (or #3267 literal ledger) via the shared
  * literal-acceptance runner. Records source_rung in the result message.
- * Project floor with empty commands is a soft pass (suite gates own the floor
- * inside full `task check`); standalone done paths still surface the rung.
+ * Project floor with empty commands is a soft pass only when a suite floor
+ * exists (suite gates own the floor inside full `task check`). With no suite
+ * floor, empty resolution is soft_empty — not a green run (#3334).
  */
 import { type EvaluateLiteralAcceptanceOptions, type LiteralAcceptanceGateResult } from "../literal-acceptance/index.js";
+import { type ClauseWalkResult } from "../verify-ac/clauses.js";
+import { type VerifyAcResolution } from "./empty-resolution.js";
 import type { AcSourceRung, PlanAcceptance } from "./types.js";
 export interface VerifyAcResult extends LiteralAcceptanceGateResult {
     readonly sourceRung: AcSourceRung;
     readonly noneStated: boolean;
     readonly acceptance: PlanAcceptance;
+    readonly resolution: VerifyAcResolution;
+    readonly resolvedCommandCount: number;
+    readonly clauseOutcomes?: readonly ClauseWalkResult[];
+    readonly clauseWalked?: boolean;
 }
 export interface EvaluateVerifyAcOptions extends EvaluateLiteralAcceptanceOptions {
     /**
@@ -36,6 +43,31 @@ export interface EvaluateVerifyAcOptions extends EvaluateLiteralAcceptanceOption
     readonly bankOnPass?: boolean;
     /** Optional scope id override for the bank ledger (default plan.id / path). */
     readonly bankScopeId?: string | null;
+    /**
+     * Injected run-summary JSONL for product-oracle integrity (#3322).
+     * Undefined → read DEFT_RUN_SUMMARY_PATH / default dest; null → skip disk.
+     */
+    readonly runSummaryText?: string | null;
+    /** When false, skip #3322 oracle integrity. Default true. */
+    readonly applyOracleIntegrity?: boolean;
+    /** Env seam for run-summary dest resolution (#3322 / #3334). */
+    readonly env?: NodeJS.ProcessEnv;
+    /**
+     * Inject suite-floor detection (tests). Default: framework source has a
+     * suite floor; consumer projects do not (#3334).
+     */
+    readonly hasSuiteFloor?: boolean;
+    /**
+     * When true, skip the acceptance run-summary emit so the path helper can
+     * emit after the #3285 bank checkpoint.
+     */
+    readonly skipAcceptanceEmit?: boolean;
+    /**
+     * Active scope key for product-oracle check_id namespacing (#3337).
+     * Prefer plan.id; path stem when id is missing. Multi-active verify:ac
+     * under one session must not share a single global `verify:ac` check id.
+     */
+    readonly oracleScopeKey?: string | null;
 }
 /**
  * Evaluate product AC from an in-memory plan.
@@ -45,6 +77,12 @@ export declare function evaluateVerifyAcFromPlan(plan: Record<string, unknown>,
  * Evaluate from xBRIEF path.
  */
 export declare function evaluateVerifyAcFromPath(xbriefPath: string, options?: EvaluateVerifyAcOptions): VerifyAcResult;
+/**
+ * Unique product-oracle scope key for one active xBRIEF path (#3337).
+ * Relative path is always unique across active roots; plan.id alone is not
+ * (duplicate ids / same stem in xbrief+vbrief). Prefer `id@relPath` when both exist.
+ */
+export declare function resolveOracleScopeKey(plan: Record<string, unknown>, xbriefPath: string, projectRoot: string): string;
 /** Pure: product AC is required at every ceremony depth (#3284 / #3267 / #3156). */
 export declare function isVerifyAcRequiredAtCeremonyDepth(_depth: string | null | undefined): boolean;
 //# sourceMappingURL=evaluate.d.ts.map