@deftai/directive-core 0.102.0 → 0.104.0

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

@@ -8,7 +8,8 @@
  * floor, empty resolution is soft_empty — not a green run (#3334).
  */
 import { existsSync, readFileSync } from "node:fs";
-import { basename, resolve } from "node:path";
+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";
@@ -26,6 +27,12 @@ function asRecord(value) {
  * Evaluate product AC from an in-memory plan.
  */
 export function evaluateVerifyAcFromPlan(plan, options = {}) {
+    const planId = typeof plan.id === "string" && plan.id.trim() ? plan.id.trim() : null;
+    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);
     // Only hard-fail schema when an explicit plan.acceptance object exists.
@@ -41,9 +48,9 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
             acceptance,
             resolution: "config",
             resolvedCommandCount: 0,
-        }, options);
+        }, optionsWithScope);
     }
-    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const projectRoot = resolve(optionsWithScope.projectRoot ?? process.cwd());
     // Prefer shared literal-acceptance path so safety / promotion rules stay one place.
     // Empty plan.acceptance.commands still consults the #3267 rejected ledger
     // (Greptile P1: rejected stated AC must never soft-pass).
@@ -51,12 +58,13 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
     // if the literal ledger is empty of executables.
     const base = evaluateLiteralAcceptanceFromPlan(plan, {
         projectRoot,
-        runner: options.runner,
+        runner: optionsWithScope.runner,
         // Check composition uses the stamped ledger only. Re-scanning issue prose
         // during `task check` re-captures backtick `verify:ac` lines as rejected
         // and deadlocks the graph (#3323 / #3284 check-integrated).
-        captureFromNarratives: options.captureFromNarratives ?? (options.checkIntegrated === true ? false : undefined),
-        quiet: options.quiet,
+        captureFromNarratives: optionsWithScope.captureFromNarratives ??
+            (optionsWithScope.checkIntegrated === true ? false : undefined),
+        quiet: optionsWithScope.quiet,
     });
     // When literal path had nothing executable but plan.acceptance has derived commands,
     // run them directly with source=explicit semantics.
@@ -64,7 +72,7 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
         base.runs.length === 0 &&
         acceptance.commands.length > 0 &&
         (acceptance.source_rung === "derived" || acceptance.source_rung === "project_floor")) {
-        const runner = options.runner;
+        const runner = optionsWithScope.runner;
         const direct = runLiteralAcceptanceCommands(acceptance.commands.map((c) => ({
             command: c.command,
             cwd: c.cwd ?? null,
@@ -72,17 +80,21 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
             expectedExitCode: c.expectedExitCode ?? 0,
             source: "explicit",
             sourceSpan: "plan.acceptance.commands",
-        })), { projectRoot, runner, allowTaskStatement: options.allowTaskStatement });
-        return applyOracle(annotate(direct, acceptance, options.quiet), options);
+        })), {
+            projectRoot,
+            runner,
+            allowTaskStatement: optionsWithScope.allowTaskStatement,
+        });
+        return applyOracle(annotate(direct, acceptance, optionsWithScope.quiet), optionsWithScope);
     }
     // Check composition: mid-story unpromoted capture-only may soft-pass so the
     // framework graph is not deadlocked before agents promote peers.
     // Greptile P1 #3284: safety-rejected stated commands NEVER soft-pass — they
     // block product verification until a safe alternative is promoted.
-    if (options.checkIntegrated === true && !base.ok && base.runs.length === 0) {
+    if (optionsWithScope.checkIntegrated === true && !base.ok && base.runs.length === 0) {
         const hasRejected = (base.rejected?.length ?? 0) > 0;
         if (hasRejected) {
-            return applyOracle(annotate(base, acceptance, options.quiet), options);
+            return applyOracle(annotate(base, acceptance, optionsWithScope.quiet), optionsWithScope);
         }
         const unpromoted = /capture-only|task_statement|no matching agent-promoted/i.test(base.message) ||
             (base.commands.length > 0 && base.commands.every((c) => c.source === "task_statement"));
@@ -90,7 +102,7 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
             return applyOracle({
                 ok: true,
                 code: 0,
-                message: options.quiet
+                message: optionsWithScope.quiet
                     ? ""
                     : `verify:ac advisory (#3284 check-integrated): no executable AC peers yet ` +
                         `(capture-only / empty). Done-gate standalone verify:ac still requires promotion. ` +
@@ -110,10 +122,10 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
                     rejectedCount: base.rejected?.length ?? 0,
                 }),
                 resolvedCommandCount: base.commands.length,
-            }, options);
+            }, optionsWithScope);
         }
     }
-    return applyOracle(annotate(base, acceptance, options.quiet), options);
+    return applyOracle(annotate(base, acceptance, optionsWithScope.quiet), optionsWithScope);
 }
 function classifyResolution(input) {
     if (input.resolution !== undefined) {
@@ -171,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;
     }
@@ -181,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 {
@@ -194,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,
@@ -208,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") {
@@ -242,6 +299,7 @@ function applyOracle(result, options) {
             projectRoot,
             runs: gated.runs,
             env: options.env,
+            scopeKey: options.oracleScopeKey,
         });
     }
     let next = gated;
@@ -257,7 +315,7 @@ function applyOracle(result, options) {
         }
     }
     if (options.skipAcceptanceEmit !== true) {
-        emitAcceptanceOutcome(next, options, projectRoot);
+        emitAcceptanceTelemetry(next, options, projectRoot);
     }
     return next;
 }
@@ -324,11 +382,40 @@ export function evaluateVerifyAcFromPath(xbriefPath, options = {}) {
     if (plan === null) {
         return applyOracle(configResult(`verify:ac: xBRIEF missing plan object: ${abs}`), options);
     }
-    const result = evaluateVerifyAcFromPlan(plan, { ...options, skipAcceptanceEmit: true });
-    const banked = maybeAttachAcPassBank(result, plan, abs, options);
-    emitAcceptanceOutcome(banked, options, resolve(options.projectRoot ?? process.cwd()));
+    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 emitOptions = {
+        ...options,
+        oracleScopeKey,
+        observedAcceptance: plan.acceptance,
+    };
+    const result = evaluateVerifyAcFromPlan(plan, {
+        ...emitOptions,
+        skipAcceptanceEmit: true,
+    });
+    const banked = maybeAttachAcPassBank(result, plan, abs, emitOptions);
+    emitAcceptanceTelemetry(banked, emitOptions, projectRoot);
     return banked;
 }
+/**
+ * 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 function resolveOracleScopeKey(plan, xbriefPath, projectRoot) {
+    const abs = resolve(xbriefPath);
+    const root = resolve(projectRoot);
+    let rel = relative(root, abs).replace(/\\/g, "/");
+    if (rel.length === 0 || rel.startsWith("..") || isAbsolute(rel)) {
+        rel = basename(abs);
+    }
+    const planId = typeof plan.id === "string" && plan.id.trim() ? plan.id.trim() : null;
+    if (planId !== null) {
+        return `${planId}@${rel}`;
+    }
+    return rel;
+}
 /**
  * After executable AC pass, FINALIZE the banking checkpoint (#3285).
  * Soft/advisory passes with zero runs do not bank. Fail-open on ledger errors.

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, 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, } 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;