@deftai/directive-core 0.103.0 → 0.105.0

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

@@ -4,7 +4,7 @@
  * Captures stated acceptance.commands at intake; empty requires none_stated:true.
  * Interoperates with #3267 plan.metadata.literal_acceptance_commands.
  */
-import { type AcceptanceCommand, type PlanAcceptance } from "./types.js";
+import { type AcceptanceCommand, type AcSourceRung, type PlanAcceptance } from "./types.js";
 /** Validation errors for a plan.acceptance object (empty list = valid). */
 export declare function validatePlanAcceptance(value: unknown): string[];
 /**
@@ -15,11 +15,14 @@ export declare function readPlanAcceptance(plan: Record<string, unknown> | null
 /** Attach a validated PlanAcceptance onto plan.acceptance + mirror to #3267 metadata. */
 export declare function attachPlanAcceptance(plan: Record<string, unknown>, acceptance: PlanAcceptance): Record<string, unknown>;
 /**
- * Build plan.acceptance from intake capture (#3284).
- * Stated commands → none_stated:false, source_rung:stated.
+ * Build plan.acceptance from intake capture (#3284 / #3396).
+ * Stated only when capture recorded a verbatim statement span.
  * No stated commands → none_stated:true, source_rung:project_floor (until agent derives).
  */
-export declare function buildAcceptanceFromIntakeCapture(capturedCommands: readonly AcceptanceCommand[]): PlanAcceptance;
+export declare function buildAcceptanceFromIntakeCapture(capturedCommands: readonly AcceptanceCommand[], options?: {
+    readonly hasVerbatimStatementSpan?: boolean;
+    readonly previousRung?: AcSourceRung;
+}): PlanAcceptance;
 /** Stamp plan.acceptance from existing literal capture after issue ingest. */
 export declare function stampAcceptanceFromLiteralCapture(plan: Record<string, unknown>): Record<string, unknown>;
 //# sourceMappingURL=acceptance.d.ts.map

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

@@ -4,7 +4,7 @@
  * Captures stated acceptance.commands at intake; empty requires none_stated:true.
  * Interoperates with #3267 plan.metadata.literal_acceptance_commands.
  */
-import { attachLiteralAcceptanceCommands, readStoredLiteralAcceptanceCommands, } from "../literal-acceptance/index.js";
+import { attachLiteralAcceptanceCommands, evaluateStampAcceptanceSafety, isNoopRefusalReason, isVerbatimStatementSpan, NOOP_ACCEPTANCE_REMEDIATION, readStoredLiteralAcceptanceCommands, } from "../literal-acceptance/index.js";
 import { readAcceptanceClauses, serializeAcceptanceClauses } from "../verify-ac/clauses.js";
 import { PLAN_ACCEPTANCE_KEY, } from "./types.js";
 function asRecord(value) {
@@ -100,6 +100,12 @@ export function validatePlanAcceptance(value) {
         errors.push("plan.acceptance: none_stated:true with source_rung:stated is contradictory " +
             "(use source_rung:derived when commands are agent-authored under none_stated)");
     }
+    for (const cmd of commands) {
+        const stamp = evaluateStampAcceptanceSafety({ commands: [{ command: cmd.command }] });
+        if (!stamp.ok && isNoopRefusalReason(stamp.reason)) {
+            errors.push(stamp.reason ?? NOOP_ACCEPTANCE_REMEDIATION);
+        }
+    }
     return errors;
 }
 /**
@@ -218,11 +224,11 @@ export function attachPlanAcceptance(plan, acceptance) {
     return next;
 }
 /**
- * Build plan.acceptance from intake capture (#3284).
- * Stated commands → none_stated:false, source_rung:stated.
+ * Build plan.acceptance from intake capture (#3284 / #3396).
+ * Stated only when capture recorded a verbatim statement span.
  * No stated commands → none_stated:true, source_rung:project_floor (until agent derives).
  */
-export function buildAcceptanceFromIntakeCapture(capturedCommands) {
+export function buildAcceptanceFromIntakeCapture(capturedCommands, options = {}) {
     if (capturedCommands.length === 0) {
         return {
             commands: [],
@@ -231,17 +237,82 @@ export function buildAcceptanceFromIntakeCapture(capturedCommands) {
             derived_reason: "no shell acceptance commands stated in task text; floor until agent derives AC (#3284 ladder)",
         };
     }
+    const stamp = evaluateStampAcceptanceSafety({
+        commands: capturedCommands.map((cmd) => ({ command: cmd.command })),
+        previousRung: options.previousRung,
+    });
+    if (!stamp.ok) {
+        throw new Error(stamp.reason ?? NOOP_ACCEPTANCE_REMEDIATION);
+    }
+    const sourceRung = options.hasVerbatimStatementSpan === true ? "stated" : "derived";
     return {
         commands: capturedCommands,
-        none_stated: false,
-        source_rung: "stated",
-        derived_reason: null,
+        none_stated: sourceRung !== "stated",
+        source_rung: sourceRung,
+        derived_reason: sourceRung === "stated"
+            ? null
+            : "no recorded verbatim statement span; derived not stated (#3396)",
     };
 }
+function rawStampCommandStrings(plan) {
+    const out = [];
+    const seen = new Set();
+    const push = (value) => {
+        if (typeof value === "string" && value.trim().length > 0) {
+            const command = value.trim();
+            if (seen.has(command))
+                return;
+            seen.add(command);
+            out.push(command);
+            return;
+        }
+        const rec = asRecord(value);
+        if (rec === null)
+            return;
+        const command = rec.command ?? rec.cmd ?? rec.shell;
+        if (isNonEmptyString(command)) {
+            const trimmed = command.trim();
+            if (seen.has(trimmed))
+                return;
+            seen.add(trimmed);
+            out.push(trimmed);
+        }
+    };
+    const acceptance = asRecord(plan[PLAN_ACCEPTANCE_KEY]);
+    if (acceptance !== null && Array.isArray(acceptance.commands)) {
+        for (const entry of acceptance.commands) {
+            push(entry);
+        }
+    }
+    const metadata = asRecord(plan.metadata);
+    if (metadata !== null) {
+        const explicit = metadata.literal_acceptance_commands ?? metadata.literalAcceptanceCommands;
+        if (Array.isArray(explicit)) {
+            for (const entry of explicit) {
+                push(entry);
+            }
+        }
+    }
+    return out;
+}
 /** Stamp plan.acceptance from existing literal capture after issue ingest. */
 export function stampAcceptanceFromLiteralCapture(plan) {
+    const previous = asRecord(plan[PLAN_ACCEPTANCE_KEY]);
+    const previousRung = isAcSourceRung(previous?.source_rung) ? previous.source_rung : undefined;
+    const attempted = rawStampCommandStrings(plan);
+    const refuse = evaluateStampAcceptanceSafety({
+        commands: attempted.map((command) => ({ command })),
+        previousRung,
+    });
+    if (!refuse.ok) {
+        throw new Error(refuse.reason ?? NOOP_ACCEPTANCE_REMEDIATION);
+    }
     const literal = readStoredLiteralAcceptanceCommands(plan);
-    const acceptance = buildAcceptanceFromIntakeCapture(literal.map(literalToAcceptance));
+    const hasVerbatimStatementSpan = literal.some((cmd) => cmd.source === "task_statement" && isVerbatimStatementSpan(cmd.sourceSpan ?? null));
+    const acceptance = buildAcceptanceFromIntakeCapture(literal.map(literalToAcceptance), {
+        hasVerbatimStatementSpan,
+        previousRung,
+    });
     // Avoid re-mirroring task_statement into verify_commands (ingest strips those).
     const serializable = {
         commands: acceptance.commands.map((c) => {

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

@@ -7,8 +7,10 @@
 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";
+export declare const EMPTY_AC_REMEDY = "stamp plan.acceptance via clause derivation (scope:activate / scope:promote runs #3323, or task issue:ingest)";
+export declare const TRANSCRIPT_EMPTY_CAUSE = "transcript skip left zero captured commands";
+export declare const TRANSCRIPT_EMPTY_REMEDY = "stamp real acceptance commands; suite-floor empty-pass does not apply when a transcript fence dropped prompt lines (#3511)";
+export type VerifyAcResolution = "verified-pass" | "empty-pass" | "soft_empty" | "fail" | "config" | "skipped" | "rejected-noop";
 /** 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;
@@ -23,4 +25,5 @@ export interface EmptyAcResolutionInput {
 /** 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;
+export declare function formatTranscriptEmptyMessage(acceptance: PlanAcceptance, quiet?: boolean): string;
 //# sourceMappingURL=empty-resolution.d.ts.map

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

@@ -7,7 +7,9 @@
 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)";
+export const EMPTY_AC_REMEDY = "stamp plan.acceptance via clause derivation (scope:activate / scope:promote runs #3323, or task issue:ingest)";
+export const TRANSCRIPT_EMPTY_CAUSE = "transcript skip left zero captured commands";
+export const TRANSCRIPT_EMPTY_REMEDY = "stamp real acceptance commands; suite-floor empty-pass does not apply when a transcript fence dropped prompt lines (#3511)";
 /** True when this project check composition includes a suite gate (#3188). */
 export function projectHasSuiteFloor(projectRoot) {
     return isFrameworkRepoRoot(projectRoot);
@@ -17,7 +19,9 @@ export function isSoftEmptyAcText(text) {
 }
 /** Zero executable commands, no rejected/unpromoted ledger, not already classified. */
 export function isEmptyAcResolution(input) {
-    if (input.resolution === "config" || input.resolution === "skipped") {
+    if (input.resolution === "config" ||
+        input.resolution === "skipped" ||
+        input.resolution === "rejected-noop") {
         return false;
     }
     if (input.code === 2) {
@@ -35,4 +39,11 @@ export function formatSoftEmptyMessage(acceptance, quiet) {
     return (`verify:ac ${EMPTY_AC_OUTCOME} (#3334) [rung=${acceptance.source_rung}]: ` +
         `${EMPTY_AC_CAUSE}. ${EMPTY_AC_REMEDY}.`);
 }
+export function formatTranscriptEmptyMessage(acceptance, quiet) {
+    if (quiet) {
+        return "";
+    }
+    return (`verify:ac FAILED (#3511) [rung=${acceptance.source_rung}]: ` +
+        `${TRANSCRIPT_EMPTY_CAUSE}. ${TRANSCRIPT_EMPTY_REMEDY}.`);
+}
 //# sourceMappingURL=empty-resolution.js.map

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

@@ -8,6 +8,8 @@
  * floor, empty resolution is soft_empty — not a green run (#3334).
  */
 import { type EvaluateLiteralAcceptanceOptions, type LiteralAcceptanceGateResult } from "../literal-acceptance/index.js";
+import { type AcceptanceRunSummaryOutcome } from "../run-summary/index.js";
+import { type AcServedFrom } from "../session/verify-ac-session-cache.js";
 import { type ClauseWalkResult } from "../verify-ac/clauses.js";
 import { type VerifyAcResolution } from "./empty-resolution.js";
 import type { AcSourceRung, PlanAcceptance } from "./types.js";
@@ -19,6 +21,8 @@ export interface VerifyAcResult extends LiteralAcceptanceGateResult {
     readonly resolvedCommandCount: number;
     readonly clauseOutcomes?: readonly ClauseWalkResult[];
     readonly clauseWalked?: boolean;
+    /** How the result was obtained (#3387). */
+    readonly servedFrom?: AcServedFrom;
 }
 export interface EvaluateVerifyAcOptions extends EvaluateLiteralAcceptanceOptions {
     /**
@@ -62,17 +66,42 @@ export interface EvaluateVerifyAcOptions extends EvaluateLiteralAcceptanceOption
      * emit after the #3285 bank checkpoint.
      */
     readonly skipAcceptanceEmit?: boolean;
+    /**
+     * Raw plan.acceptance as observed on the brief (#3355). Distinct from the
+     * synthesized floor: stamp only when the plan actually carries a block.
+     */
+    readonly observedAcceptance?: unknown;
     /**
      * 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;
+    /**
+     * Reuse a matching #3285 bank / same-session cache (#3387).
+     * - auto (default): cache then bank
+     * - bank: complete walk — bank only
+     * - never: always execute
+     */
+    readonly reuseMode?: "auto" | "bank" | "never";
+    readonly sessionId?: string | null;
+    readonly productPaths?: readonly string[];
 }
 /**
  * Evaluate product AC from an in-memory plan.
  */
 export declare function evaluateVerifyAcFromPlan(plan: Record<string, unknown>, options?: EvaluateVerifyAcOptions): VerifyAcResult;
+/**
+ * CLI-only early returns that never reach evaluate still emit an acceptance
+ * outcome so field streams see config-error / soft-missing (#3355).
+ */
+export declare function emitVerifyAcTerminalOutcome(input: {
+    readonly projectRoot: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly outcome: AcceptanceRunSummaryOutcome;
+    readonly sourceRung?: AcSourceRung;
+    readonly noneStated?: boolean;
+}): void;
 /**
  * Evaluate from xBRIEF path.
  */