@deftai/directive-core 0.103.0 → 0.104.0

package/dist/intake/clause-derivation.js

@@ -0,0 +1,207 @@
+/**
+ * Hand-authored briefs run #3323 clause derivation on activate/promote (#3360).
+ *
+ * issue:ingest already stamps clauses. The dominant consumer path authors the
+ * brief by hand; #3334 only required plan.acceptance to exist. This module is
+ * the missing derive step.
+ */
+import { ENV_RUN_SUMMARY_PATH, RunSummaryEmitter } from "../run-summary/index.js";
+import { deriveAcceptanceClauses, readAcceptanceClauses, serializeAcceptanceClauses, } from "../verify-ac/clauses.js";
+const NARRATIVE_KEYS = [
+    "Overview",
+    "Description",
+    "Acceptance",
+    "AcceptanceCriteria",
+    "Acceptance sketch",
+    "AcceptanceSketch",
+    "Test",
+    "Verification",
+    "ImplementationPlan",
+];
+function asRecord(value) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+/** True when activate/promote must run #3323 (absent, empty none_stated, or command-only). */
+export function needsClauseDerivation(acceptance) {
+    if (acceptance === undefined || acceptance === null) {
+        return true;
+    }
+    const rec = asRecord(acceptance);
+    if (rec === null) {
+        return true;
+    }
+    return !(Array.isArray(rec.clauses) && rec.clauses.length > 0);
+}
+/** Task-statement text from title, narratives, and item Acceptance fields. */
+export function collectTaskStatementFromPlan(plan) {
+    const parts = [];
+    if (isNonEmptyString(plan.title)) {
+        parts.push(plan.title.trim());
+    }
+    const narratives = asRecord(plan.narratives);
+    if (narratives !== null) {
+        const seen = new Set();
+        for (const key of NARRATIVE_KEYS) {
+            const value = narratives[key];
+            if (isNonEmptyString(value)) {
+                parts.push(value.trim());
+                seen.add(key.toLowerCase());
+            }
+        }
+        for (const [key, value] of Object.entries(narratives)) {
+            if (seen.has(key.toLowerCase()) || !isNonEmptyString(value)) {
+                continue;
+            }
+            parts.push(value.trim());
+        }
+    }
+    if (Array.isArray(plan.items)) {
+        for (const item of plan.items) {
+            const rec = asRecord(item);
+            if (rec === null) {
+                continue;
+            }
+            const narrative = asRecord(rec.narrative);
+            const text = narrative?.Acceptance;
+            if (isNonEmptyString(text)) {
+                parts.push(text.trim());
+            }
+        }
+    }
+    return parts.join("\n\n");
+}
+function formatAmbiguousClauseNotice(clauses) {
+    const flagged = clauses.filter((clause) => clause.ambiguous);
+    const lines = [
+        `#3323 clause derivation stamped ${clauses.length} clause(s)` +
+            (flagged.length > 0 ? `; flagged-ambiguous: ${flagged.length}` : ""),
+    ];
+    for (const clause of flagged) {
+        const chosen = clause.chosen_reading ?? 0;
+        const chosenPath = clause.readings?.[chosen]?.artifact_path ?? clause.artifact_path ?? "(none)";
+        lines.push(`  clause ${clause.id}: two readings; chosen_reading=${chosen} (${chosenPath}) [headless #3323]`);
+        for (const [index, reading] of (clause.readings ?? []).entries()) {
+            lines.push(`    reading ${index}: ${reading.artifact_path ?? "(none)"}`);
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Stamp derived clauses onto plan.acceptance in place. Headless: records
+ * chosen_reading, never blocks on a question.
+ */
+export function applyClauseDerivationToPlan(plan, options = {}) {
+    if (!needsClauseDerivation(plan.acceptance)) {
+        return {
+            applied: false,
+            clauses: readAcceptanceClauses(plan.acceptance),
+            notice: "",
+        };
+    }
+    const clauses = deriveAcceptanceClauses(collectTaskStatementFromPlan(plan));
+    if (clauses.length === 0) {
+        return { applied: false, clauses: [], notice: "" };
+    }
+    const existing = asRecord(plan.acceptance);
+    const commands = existing !== null && Array.isArray(existing.commands) ? existing.commands : [];
+    const hasCommands = commands.length > 0;
+    const noneStated = hasCommands ? existing?.none_stated === true : true;
+    const sourceRung = hasCommands && existing?.none_stated !== true
+        ? isNonEmptyString(existing?.source_rung)
+            ? existing.source_rung
+            : "stated"
+        : "derived";
+    plan.acceptance = {
+        ...(existing ?? {}),
+        commands: hasCommands ? commands : [],
+        none_stated: noneStated,
+        source_rung: sourceRung,
+        derived_reason: `derived ${clauses.length} independently testable clauses from the task statement before product edit (#3323)`,
+        clauses: serializeAcceptanceClauses(clauses),
+    };
+    if (options.emitStamp !== false && options.projectRoot !== undefined) {
+        emitAcceptanceStampFromPlan(options.projectRoot, plan);
+    }
+    return {
+        applied: true,
+        clauses,
+        notice: formatAmbiguousClauseNotice(clauses),
+    };
+}
+/** Stable fingerprint of plan.acceptance for first-write / material-change detection (#3355). */
+export function acceptanceFingerprint(acceptance) {
+    const rec = asRecord(acceptance);
+    if (rec === null) {
+        return null;
+    }
+    const commands = Array.isArray(rec.commands) ? rec.commands.length : 0;
+    const clauses = Array.isArray(rec.clauses)
+        ? rec.clauses.map((entry, index) => {
+            const row = asRecord(entry);
+            if (row === null) {
+                return `${index}`;
+            }
+            return `${row.id ?? index}:${row.text ?? ""}:${row.artifact_path ?? ""}`;
+        })
+        : [];
+    const rung = typeof rec.source_rung === "string" ? rec.source_rung : "";
+    return `${rung}|${rec.none_stated === true}|${commands}|${clauses.join(";")}`;
+}
+/** True when next is a first write or a material change versus previous (#3355). */
+export function isMaterialAcceptanceChange(previous, next) {
+    const nextFp = acceptanceFingerprint(next);
+    if (nextFp === null) {
+        return false;
+    }
+    return acceptanceFingerprint(previous) !== nextFp;
+}
+/** Fail-open acceptance_stamp emission (same contract as issue:ingest / #3355). */
+export function emitAcceptanceStampFromPlan(projectRoot, plan, env = process.env) {
+    const rec = asRecord(plan);
+    if (rec === null) {
+        return;
+    }
+    const acceptance = asRecord(rec.acceptance);
+    if (acceptance === null) {
+        return;
+    }
+    const dest = env[ENV_RUN_SUMMARY_PATH];
+    if (dest === undefined || dest.trim().length === 0) {
+        return;
+    }
+    try {
+        const sessionId = typeof env.DEFT_SESSION_ID === "string" && env.DEFT_SESSION_ID.trim().length > 0
+            ? env.DEFT_SESSION_ID.trim()
+            : "clause-derivation";
+        const emitter = new RunSummaryEmitter({ projectRoot, sessionId, env });
+        const commands = Array.isArray(acceptance.commands) ? acceptance.commands.length : 0;
+        const clauses = Array.isArray(acceptance.clauses) ? acceptance.clauses.length : 0;
+        emitter.emitAcceptanceStamp({
+            rung: typeof acceptance.source_rung === "string" ? acceptance.source_rung : "project_floor",
+            none_stated: acceptance.none_stated === true,
+            command_count: commands,
+            clause_count: clauses,
+        });
+    }
+    catch {
+        // fail-open
+    }
+}
+/**
+ * Emit acceptance_stamp when plan.acceptance is first written or materially changed.
+ * State-observed: callers pass the before/after blocks from any lifecycle verb (#3355).
+ */
+export function maybeEmitAcceptanceStampFromChange(projectRoot, previous, next, env = process.env) {
+    if (!isMaterialAcceptanceChange(previous, next)) {
+        return false;
+    }
+    emitAcceptanceStampFromPlan(projectRoot, { acceptance: next }, env);
+    return true;
+}
+//# sourceMappingURL=clause-derivation.js.map

package/dist/intake/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./candidates-log.js";
+export * from "./clause-derivation.js";
 export * from "./github-auth-modes.js";
 export { resultToDict } from "./github-auth-modes.js";
 export * from "./github-body.js";

package/dist/intake/index.js

@@ -1,4 +1,5 @@
 export * from "./candidates-log.js";
+export * from "./clause-derivation.js";
 export * from "./github-auth-modes.js";
 export { resultToDict } from "./github-auth-modes.js";
 export * from "./github-body.js";

package/dist/intake/issue-ingest.js

@@ -6,7 +6,6 @@ import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/project
 import { hasArtifactSuffix, resolveLifecycleRoot } from "../layout/resolve.js";
 import { captureAndAttachLiteralAcceptance } from "../literal-acceptance/index.js";
 import { stampAcceptanceFromLiteralCapture } from "../product-first-done-gate/index.js";
-import { ENV_RUN_SUMMARY_PATH, RunSummaryEmitter } from "../run-summary/index.js";
 import { call } from "../scm/call.js";
 import { resolveProjectRoot } from "../scope/project-context.js";
 import { resolveProjectRepo } from "../slice/project-context.js";
@@ -15,6 +14,7 @@ import { slugify, TODAY } from "../vbrief-build/build.js";
 import { EMITTED_VBRIEF_VERSION } from "../vbrief-build/constants.js";
 import { stampDerivedClausesOnAcceptance } from "../verify-ac/clauses.js";
 import { LEGACY_ARTIFACT_SUFFIX, LEGACY_INFO_ROOT_KEY, MIGRATED_ARTIFACT_DIR, MIGRATED_ARTIFACT_SUFFIX, MIGRATED_INFO_ROOT_KEY, VBRIEF_VERSION, } from "../xbrief-migrate/constants.js";
+import { emitAcceptanceStampFromPlan } from "./clause-derivation.js";
 import { findAcHeading, parseCheckboxItems, parseListItems, sliceAcSection, stripCodeBlocks, stripFencedCodeBlocks, } from "./markdown-scanners.js";
 import { detectRepo, extractReferencesFromVbrief, fetchOpenIssues, GITHUB_ISSUE_REF_TYPES, LIFECYCLE_FOLDERS, parseIssueNumber, } from "./reconcile-issues.js";
 /** Reference type pointing at the canonical current-shape comment permalink (#1870). */
@@ -723,45 +723,9 @@ export function ingestOne(issue, options) {
     assertWriteTargetSafe(projectRoot, target);
     mkdirSync(folderPath, { recursive: true });
     writeFileSync(target, `${JSON.stringify(vbrief, null, 2)}\n`, "utf8");
-    emitIntakeAcceptanceStamp(projectRoot, vbrief.plan);
+    emitAcceptanceStampFromPlan(projectRoot, vbrief.plan);
     return ["created", target, `CREATED ${folder}/${filename}`];
 }
-function emitIntakeAcceptanceStamp(projectRoot, plan) {
-    const rec = plan !== null && typeof plan === "object" && !Array.isArray(plan)
-        ? plan
-        : null;
-    if (rec === null) {
-        return;
-    }
-    const acceptance = rec.acceptance !== null && typeof rec.acceptance === "object" && !Array.isArray(rec.acceptance)
-        ? rec.acceptance
-        : null;
-    if (acceptance === null) {
-        return;
-    }
-    const env = process.env;
-    const dest = env[ENV_RUN_SUMMARY_PATH];
-    if (dest === undefined || dest.trim().length === 0) {
-        return;
-    }
-    try {
-        const sessionId = typeof env.DEFT_SESSION_ID === "string" && env.DEFT_SESSION_ID.trim().length > 0
-            ? env.DEFT_SESSION_ID.trim()
-            : "issue-ingest";
-        const emitter = new RunSummaryEmitter({ projectRoot, sessionId, env });
-        const commands = Array.isArray(acceptance.commands) ? acceptance.commands.length : 0;
-        const clauses = Array.isArray(acceptance.clauses) ? acceptance.clauses.length : 0;
-        emitter.emitAcceptanceStamp({
-            rung: typeof acceptance.source_rung === "string" ? acceptance.source_rung : "project_floor",
-            none_stated: acceptance.none_stated === true,
-            command_count: commands,
-            clause_count: clauses,
-        });
-    }
-    catch {
-        // fail-open
-    }
-}
 export function ingestBulk(issues, options) {
     let filtered = issues;
     if (options.label !== undefined && options.label !== null) {

package/dist/preflight/evaluate.d.ts

@@ -1,4 +1,5 @@
 import { type ParentLineageResult } from "../scope/parent-lineage.js";
+import { type FetchOriginUpdatedAt } from "../vbrief-reconcile/origin-freshness.js";
 /** Canonical eligibility folder — only vbrief/active/ may spawn implementation. */
 export declare const ACTIVE_FOLDER = "active";
 /** Canonical eligibility status — only `running` signals an active handoff. */
@@ -20,6 +21,10 @@ export interface EvaluateOptions {
     readonly projectRoot?: string;
     /** Skip parent-lineage check (tests / opt-out). Default false. */
     readonly skipParentLineage?: boolean;
+    /** Skip origin timestamp freshness (#3363). Default false. */
+    readonly skipOriginFreshness?: boolean;
+    /** Injected origin fetch for tests. Default: live `gh api` REST. */
+    readonly fetchOriginUpdatedAt?: FetchOriginUpdatedAt;
 }
 /** Substitute `{path}` without `$`-pattern expansion in user paths (#1721). */
 export declare function formatActivateHint(path: string): string;

package/dist/preflight/evaluate.js

@@ -2,6 +2,7 @@ import { readFileSync, statSync } from "node:fs";
 import { basename, dirname } from "node:path";
 import { evaluateIntentCeilingFromEnv } from "../policy/intent-ceiling.js";
 import { evaluateParentLineage, formatParentLineageLine, } from "../scope/parent-lineage.js";
+import { evaluateOriginFreshness, } from "../vbrief-reconcile/origin-freshness.js";
 /** Canonical eligibility folder — only vbrief/active/ may spawn implementation. */
 export const ACTIVE_FOLDER = "active";
 /** Canonical eligibility status — only `running` signals an active handoff. */
@@ -154,6 +155,19 @@ export function evaluate(vbriefPath, options = {}) {
             message: buildReject(path, `${lineage.message}${defect}\n  ${formatParentLineageLine(lineage)}`),
         };
     }
+    // #3363: fail closed when the live GitHub origin is newer than the brief.
+    const originFreshness = evaluateOriginFreshness(record, {
+        skip: options.skipOriginFreshness === true,
+        fetchOriginUpdatedAt: options.fetchOriginUpdatedAt,
+        cwd: options.projectRoot,
+    });
+    if (!originFreshness.ok) {
+        return {
+            exitCode: 1,
+            parentLineage: lineage,
+            message: buildReject(path, originFreshness.message),
+        };
+    }
     // Keep the historical OK line when lineage is N/A (backward-compatible tests / agents).
     const message = lineage.applicable
         ? `OK ${path} -- ready for implementation. parent lineage OK ` +

package/dist/preflight/index.d.ts

@@ -1,3 +1,3 @@
-export type { EvaluateResult } from "./evaluate.js";
+export type { EvaluateOptions, EvaluateResult } from "./evaluate.js";
 export { ACTIVATE_HINT, ACTIVE_FOLDER, ELIGIBLE_LIFECYCLE_DIRS, ELIGIBLE_STATUS, emitJson, evaluate, formatActivateHint, PREFLIGHT_USAGE_HINT, } from "./evaluate.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -7,7 +7,7 @@
 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 declare const EMPTY_AC_REMEDY = "stamp plan.acceptance via clause derivation (scope:activate / scope:promote runs #3323, or 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;

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

@@ -7,7 +7,7 @@
 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)";
 /** True when this project check composition includes a suite gate (#3188). */
 export function projectHasSuiteFloor(projectRoot) {
     return isFrameworkRepoRoot(projectRoot);

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

@@ -8,6 +8,7 @@
  * 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 ClauseWalkResult } from "../verify-ac/clauses.js";
 import { type VerifyAcResolution } from "./empty-resolution.js";
 import type { AcSourceRung, PlanAcceptance } from "./types.js";
@@ -62,6 +63,11 @@ 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
@@ -73,6 +79,17 @@ export interface EvaluateVerifyAcOptions extends EvaluateLiteralAcceptanceOption
  * 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.
  */

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

@@ -9,6 +9,7 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { basename, isAbsolute, relative, resolve } from "node:path";
+import { emitAcceptanceStampFromPlan } from "../intake/clause-derivation.js";
 import { evaluateLiteralAcceptanceFromPlan, runLiteralAcceptanceCommands, } from "../literal-acceptance/index.js";
 import { ENV_RUN_SUMMARY_PATH, RunSummaryEmitter, } from "../run-summary/index.js";
 import { maybeBankOnAcPass } from "../session/ac-pass-banking.js";
@@ -30,6 +31,7 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
     const optionsWithScope = {
         ...options,
         oracleScopeKey: options.oracleScopeKey?.trim() || planId || null,
+        observedAcceptance: options.observedAcceptance !== undefined ? options.observedAcceptance : plan.acceptance,
     };
     const acceptance = readPlanAcceptance(plan);
     const schemaErrors = validatePlanAcceptance(plan.acceptance ?? acceptance);
@@ -181,9 +183,11 @@ function acceptanceOutcomeOf(result) {
         return "soft_empty";
     if (result.resolution === "fail")
         return "fail";
-    return null;
+    if (result.resolution === "config")
+        return "config-error";
+    return "soft-missing";
 }
-function emitAcceptanceOutcome(result, options, projectRoot) {
+function emitAcceptanceObservedStamp(options, projectRoot) {
     if (options.env === undefined) {
         return;
     }
@@ -191,8 +195,14 @@ function emitAcceptanceOutcome(result, options, projectRoot) {
     if (dest === undefined || dest.trim().length === 0) {
         return;
     }
-    const outcome = acceptanceOutcomeOf(result);
-    if (outcome === null) {
+    emitAcceptanceStampFromPlan(projectRoot, { acceptance: options.observedAcceptance }, options.env);
+}
+function emitAcceptanceOutcome(result, options, projectRoot) {
+    if (options.env === undefined) {
+        return;
+    }
+    const dest = options.env[ENV_RUN_SUMMARY_PATH];
+    if (dest === undefined || dest.trim().length === 0) {
         return;
     }
     try {
@@ -204,7 +214,7 @@ function emitAcceptanceOutcome(result, options, projectRoot) {
         });
         emitter.emitAcceptance({
             resolved_command_count: result.resolvedCommandCount,
-            outcome,
+            outcome: acceptanceOutcomeOf(result),
             source_rung: result.sourceRung,
             none_stated: result.noneStated,
             clause_count: result.clauseOutcomes?.length,
@@ -218,6 +228,43 @@ function emitAcceptanceOutcome(result, options, projectRoot) {
         // fail-open
     }
 }
+/** Outcome on every terminal path; stamp from observed plan.acceptance (#3355). */
+function emitAcceptanceTelemetry(result, options, projectRoot) {
+    emitAcceptanceObservedStamp(options, projectRoot);
+    emitAcceptanceOutcome(result, options, projectRoot);
+}
+/**
+ * CLI-only early returns that never reach evaluate still emit an acceptance
+ * outcome so field streams see config-error / soft-missing (#3355).
+ */
+export function emitVerifyAcTerminalOutcome(input) {
+    emitAcceptanceOutcome({
+        ok: input.outcome !== "config-error" && input.outcome !== "fail",
+        code: input.outcome === "config-error" ? 2 : input.outcome === "fail" ? 1 : 0,
+        message: "",
+        commands: [],
+        runs: [],
+        sourceRung: input.sourceRung ?? "project_floor",
+        noneStated: input.noneStated ?? true,
+        acceptance: {
+            commands: [],
+            none_stated: input.noneStated ?? true,
+            source_rung: input.sourceRung ?? "project_floor",
+        },
+        resolution: input.outcome === "config-error"
+            ? "config"
+            : input.outcome === "soft-missing"
+                ? "skipped"
+                : input.outcome === "fail"
+                    ? "fail"
+                    : input.outcome === "soft_empty"
+                        ? "soft_empty"
+                        : input.outcome === "verified-pass"
+                            ? "verified-pass"
+                            : "empty-pass",
+        resolvedCommandCount: 0,
+    }, { projectRoot: input.projectRoot, env: input.env }, resolve(input.projectRoot));
+}
 function applyClauseWalk(result, options) {
     const clauses = result.acceptance.clauses ?? [];
     if (clauses.length === 0 || result.resolution === "config" || result.resolution === "skipped") {
@@ -268,7 +315,7 @@ function applyOracle(result, options) {
         }
     }
     if (options.skipAcceptanceEmit !== true) {
-        emitAcceptanceOutcome(next, options, projectRoot);
+        emitAcceptanceTelemetry(next, options, projectRoot);
     }
     return next;
 }
@@ -338,13 +385,17 @@ export function evaluateVerifyAcFromPath(xbriefPath, options = {}) {
     const projectRoot = resolve(options.projectRoot ?? process.cwd());
     // Path-relative keys stay unique across xbrief/ vs vbrief/ and duplicate plan.id (#3337 Greptile).
     const oracleScopeKey = options.oracleScopeKey?.trim() || resolveOracleScopeKey(plan, abs, projectRoot);
-    const result = evaluateVerifyAcFromPlan(plan, {
+    const emitOptions = {
         ...options,
-        skipAcceptanceEmit: true,
         oracleScopeKey,
+        observedAcceptance: plan.acceptance,
+    };
+    const result = evaluateVerifyAcFromPlan(plan, {
+        ...emitOptions,
+        skipAcceptanceEmit: true,
     });
-    const banked = maybeAttachAcPassBank(result, plan, abs, options);
-    emitAcceptanceOutcome(banked, options, projectRoot);
+    const banked = maybeAttachAcPassBank(result, plan, abs, emitOptions);
+    emitAcceptanceTelemetry(banked, emitOptions, projectRoot);
     return banked;
 }
 /**

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

@@ -7,6 +7,6 @@
 export { attachPlanAcceptance, buildAcceptanceFromIntakeCapture, readPlanAcceptance, stampAcceptanceFromLiteralCapture, validatePlanAcceptance, } from "./acceptance.js";
 export { applyProductFirstGateMode, isHygieneGate, isProductAcGate, type ProductFirstCheckModeResolution, type ResolveProductFirstCheckModeInput, resolveProductFirstCheckMode, } from "./check-mode.js";
 export { EMPTY_AC_CAUSE, EMPTY_AC_OUTCOME, EMPTY_AC_REMEDY, formatSoftEmptyMessage, isEmptyAcResolution, isSoftEmptyAcText, projectHasSuiteFloor, type VerifyAcResolution, } from "./empty-resolution.js";
-export { type EvaluateVerifyAcOptions, evaluateVerifyAcFromPath, evaluateVerifyAcFromPlan, isVerifyAcRequiredAtCeremonyDepth, resolveOracleScopeKey, type VerifyAcResult, } from "./evaluate.js";
+export { type EvaluateVerifyAcOptions, emitVerifyAcTerminalOutcome, evaluateVerifyAcFromPath, evaluateVerifyAcFromPlan, isVerifyAcRequiredAtCeremonyDepth, resolveOracleScopeKey, type VerifyAcResult, } from "./evaluate.js";
 export { type AcceptanceCommand, type AcSourceRung, ENV_CHECK_AC_ONLY, ENV_CHECK_MODE, ENV_HYGIENE_ADVISORY, HYGIENE_GATE_ID_PREFIXES, PLAN_ACCEPTANCE_KEY, type PlanAcceptance, PRODUCT_AC_GATE_ID, type ProductFirstCheckMode, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -7,6 +7,6 @@
 export { attachPlanAcceptance, buildAcceptanceFromIntakeCapture, readPlanAcceptance, stampAcceptanceFromLiteralCapture, validatePlanAcceptance, } from "./acceptance.js";
 export { applyProductFirstGateMode, isHygieneGate, isProductAcGate, resolveProductFirstCheckMode, } from "./check-mode.js";
 export { EMPTY_AC_CAUSE, EMPTY_AC_OUTCOME, EMPTY_AC_REMEDY, formatSoftEmptyMessage, isEmptyAcResolution, isSoftEmptyAcText, projectHasSuiteFloor, } from "./empty-resolution.js";
-export { evaluateVerifyAcFromPath, evaluateVerifyAcFromPlan, isVerifyAcRequiredAtCeremonyDepth, resolveOracleScopeKey, } from "./evaluate.js";
+export { emitVerifyAcTerminalOutcome, evaluateVerifyAcFromPath, evaluateVerifyAcFromPlan, isVerifyAcRequiredAtCeremonyDepth, resolveOracleScopeKey, } from "./evaluate.js";
 export { ENV_CHECK_AC_ONLY, ENV_CHECK_MODE, ENV_HYGIENE_ADVISORY, HYGIENE_GATE_ID_PREFIXES, PLAN_ACCEPTANCE_KEY, PRODUCT_AC_GATE_ID, } from "./types.js";
 //# sourceMappingURL=index.js.map

package/dist/run-summary/emit.d.ts

@@ -25,8 +25,27 @@ export interface EmitRunSummaryResult {
     readonly line: RunSummaryLine | null;
     readonly warning: boolean;
 }
+/** Owner token stored in `.seq.lock` so reclaim is not age-based (#3361). */
+export interface SeqLockOwner {
+    readonly pid: number;
+    readonly nonce: string;
+}
+/**
+ * Reclaim `.seq.lock` only when the owner process is dead or the token is
+ * missing/unreadable/corrupt (unknown owner). Live holders are never stolen
+ * by mtime (#3361).
+ */
+export declare function tryReclaimSeqLock(lockPath: string): boolean;
+/**
+ * Unlink `.seq.lock` only when the on-disk token still matches this holder
+ * (ownership-blind release must not delete a successor's lock).
+ */
+export declare function releaseSeqLockIfOwner(lockPath: string, owner: SeqLockOwner): boolean;
 /**
- * Stateful emitter: one instance per session tracks seq and write-warning once.
+ * Stateful emitter: one instance tracks seq and write-warning once.
+ * File destinations seed seq from the current JSONL line count so multiple
+ * CLI processes appending to one DEFT_RUN_SUMMARY_PATH share 1..N (#3350).
+ * Stdout destinations stay per-process (each constructor starts at 0).
  */
 export declare class RunSummaryEmitter {
     private seq;
@@ -41,6 +60,7 @@ export declare class RunSummaryEmitter {
     private readonly writeStderr;
     constructor(options: RunSummaryEmitterOptions);
     getDestination(): RunSummaryDestination;
+    private buildLine;
     emit(event: RunSummaryEventKind, payload: RunSummaryPayload): EmitRunSummaryResult;
     emitSessionStart(payload: SessionStartRunSummaryPayload): EmitRunSummaryResult;
     emitDialTransition(payload: DialTransitionRunSummaryPayload): EmitRunSummaryResult;
@@ -52,12 +72,32 @@ export declare class RunSummaryEmitter {
     emitAcceptanceStamp(payload: AcceptanceStampRunSummaryPayload): EmitRunSummaryResult;
     /** Emit the harness-supplied denominator when DEFT_TOTAL_TOOL_TURNS is set. */
     emitKnownToolTurnDenominator(): EmitRunSummaryResult;
+    /**
+     * Always emit a session denominator when the destination is live (#3356).
+     * `emitKnownToolTurnDenominator` stays silent unless DEFT_TOTAL_TOOL_TURNS is
+     * set; this caller records host planned turns or the session:start CLI floor.
+     */
+    emitSessionToolTurnDenominator(hostMaxTurns?: number | null): EmitRunSummaryResult;
 }
 /** Parse harness-supplied DEFT_TOTAL_TOOL_TURNS (integer > 0). Invalid/unset → omit. */
 export declare function readEnvToolTurnDenominator(env: NodeJS.ProcessEnv): number | undefined;
+/** Canonical host planned-turn budget recorded at session:start (#3356). */
+export declare const ENV_MAX_TURNS_DENOMINATOR = "DEFT_MAX_TURNS";
+/** session:start is one CLI invocation when no host/harness count is known (#3356). */
+export declare const SESSION_START_CLI_INVOCATION_DENOMINATOR: 1;
+/**
+ * Resolve the session tool/turn denominator (#3356).
+ *
+ * Prefer harness actuals (`DEFT_TOTAL_TOOL_TURNS`), then a host planned-turn
+ * budget (`DEFT_MAX_TURNS` or `hostMaxTurns` from the session:start descriptor),
+ * else this CLI invocation (1). An emitted proxy beats a perfect unused kind.
+ */
+export declare function resolveSessionToolTurnDenominator(env: NodeJS.ProcessEnv, hostMaxTurns?: number | null): number;
 /**
  * One-shot helper for call sites that do not hold an emitter (e.g. dial escalate).
- * Still fail-open; creates a fresh seq=1 emitter unless `seqSeed` is passed via reuse.
+ * Still fail-open. File destinations seed seq from the existing JSONL line
+ * count so successive one-shot calls into the same path continue 1..N (#3350).
+ * Stdout destinations stay per-process (each call starts at seq=1).
  */
 export declare function emitRunSummaryEvent(options: RunSummaryEmitterOptions & {
     readonly event: RunSummaryEventKind;