@deftai/directive-core 0.102.0 → 0.103.0

package/dist/init-deposit/hygiene.d.ts

@@ -42,7 +42,13 @@ export declare function installerManagedMatchers(): InstallerManagedMatcher[];
  *    so an unlisted `xbrief/active/another-scope.xbrief.json` matcher still fails.
  */
 export declare function assertInstallerAllowlistHonors1430(matchers?: readonly InstallerManagedMatcher[]): void;
-/** POSIX ERE alternation embedded in the deposited deft-core-guard workflow. */
+/**
+ * Individual POSIX ERE patterns for the deposited deft-core-guard allowlist.
+ * One pattern per line in the workflow heredoc (#3345) — joined form is still
+ * available via {@link installerManagedGuardEre} for tests and classifiers.
+ */
+export declare function installerManagedGuardErePatterns(): string[];
+/** POSIX ERE alternation (joined) for tests / tooling that want a single pattern. */
 export declare function installerManagedGuardEre(): string;
 export declare function isInstallerManagedPath(path: string): boolean;
 export interface MixedCoreAndAppClassification {

package/dist/init-deposit/hygiene.js

@@ -174,12 +174,20 @@ export function assertInstallerAllowlistHonors1430(matchers = installerManagedMa
         }
     }
 }
-/** POSIX ERE alternation embedded in the deposited deft-core-guard workflow. */
-export function installerManagedGuardEre() {
+/**
+ * Individual POSIX ERE patterns for the deposited deft-core-guard allowlist.
+ * One pattern per line in the workflow heredoc (#3345) — joined form is still
+ * available via {@link installerManagedGuardEre} for tests and classifiers.
+ */
+export function installerManagedGuardErePatterns() {
     const matchers = installerManagedMatchers();
     // Refuse to emit a guard workflow that would exempt consumer denylist paths.
     assertInstallerAllowlistHonors1430(matchers);
-    return matchers.map((matcher) => matcherToEre(matcher)).join("|");
+    return matchers.map((matcher) => matcherToEre(matcher));
+}
+/** POSIX ERE alternation (joined) for tests / tooling that want a single pattern. */
+export function installerManagedGuardEre() {
+    return installerManagedGuardErePatterns().join("|");
 }
 export function isInstallerManagedPath(path) {
     return matchesInstallerManaged(path, installerManagedMatchers());

package/dist/init-deposit/scaffold.d.ts

@@ -82,6 +82,18 @@ export declare function coreGuardCheckoutUsesLine(sha?: string, tag?: string): s
  * the managed guard script / allowlist body (#1672 option 1).
  */
 export declare function mergeCoreGuardWorkflowRefresh(existing: string, desired: string): string;
+/**
+ * Soft max line length for deposited core-guard workflow YAML (#3345).
+ * Mega-line allowlist EREs previously sat near ~5k chars; keep well below.
+ * Enforced by {@link assertCoreGuardWorkflowLoadable} before deposit write.
+ */
+export declare const CORE_GUARD_WORKFLOW_MAX_LINE = 500;
+/**
+ * Fail closed if a rendered deft-core-guard workflow would not load in GHA
+ * (#3345): any `run: |` content line less indented than the block base, or a
+ * line longer than {@link CORE_GUARD_WORKFLOW_MAX_LINE}.
+ */
+export declare function assertCoreGuardWorkflowLoadable(content: string): void;
 export declare function ensureGitattributes(projectDir: string, io: InitDepositIo): boolean;
 export declare function ensureGreptileIgnore(projectDir: string, io: InitDepositIo): boolean;
 export declare function ensureCodeqlPathsIgnore(projectDir: string, io: InitDepositIo): boolean;

package/dist/init-deposit/scaffold.js

@@ -14,7 +14,7 @@ import { assertDestinationNotSymlink, ProjectionContainmentError, } from "../fs/
 import { agentsRefreshPlan } from "../platform/agents-md.js";
 import { MIGRATED_ARTIFACT_DIR } from "../xbrief-migrate/constants.js";
 import { CANONICAL_INSTALL_ROOT } from "./constants.js";
-import { assertInstallerAllowlistHonors1430, installerManagedGuardEre } from "./hygiene.js";
+import { assertInstallerAllowlistHonors1430, installerManagedGuardErePatterns } from "./hygiene.js";
 import { writeAgentsSkillsFromInventory } from "./skill-discovery-deposit.js";
 import { syncConsumerXbriefSchemas } from "./xbrief-projections.js";
 export { CANONICAL_INSTALL_ROOT };
@@ -501,16 +501,66 @@ export function mergeCoreGuardWorkflowRefresh(existing, desired) {
         return desired;
     return desired.slice(0, idx) + existingCheckout + desired.slice(idx + desiredCheckout.length);
 }
+/**
+ * Indent for shell lines inside the deposited workflow `run: |` block.
+ * YAML literal blocks end at any line less indented than this; the #3193
+ * Python body must stay at this column so GHA can load the workflow (#3345).
+ */
+const CORE_GUARD_RUN_INDENT = "          ";
+/**
+ * Soft max line length for deposited core-guard workflow YAML (#3345).
+ * Mega-line allowlist EREs previously sat near ~5k chars; keep well below.
+ * Enforced by {@link assertCoreGuardWorkflowLoadable} before deposit write.
+ */
+export const CORE_GUARD_WORKFLOW_MAX_LINE = 500;
+/**
+ * Fail closed if a rendered deft-core-guard workflow would not load in GHA
+ * (#3345): any `run: |` content line less indented than the block base, or a
+ * line longer than {@link CORE_GUARD_WORKFLOW_MAX_LINE}.
+ */
+export function assertCoreGuardWorkflowLoadable(content) {
+    if (!content.startsWith("name: deft-core-guard\n") &&
+        !content.startsWith("name: deft-core-guard\r\n")) {
+        throw new Error("deft-core-guard workflow must start with name: deft-core-guard (#3345)");
+    }
+    let inRun = false;
+    let baseIndent = null;
+    for (const [index, line] of content.split("\n").entries()) {
+        if (line.length > CORE_GUARD_WORKFLOW_MAX_LINE) {
+            throw new Error(`deft-core-guard workflow line ${index + 1} is ${line.length} chars ` +
+                `(max ${CORE_GUARD_WORKFLOW_MAX_LINE}; #3345 loadable YAML)`);
+        }
+        if (line.trim() === "run: |") {
+            inRun = true;
+            baseIndent = null;
+            continue;
+        }
+        if (!inRun || line.trim() === "")
+            continue;
+        const lead = line.match(/^( *)/)?.[1]?.length ?? 0;
+        if (baseIndent === null) {
+            baseIndent = lead;
+            continue;
+        }
+        if (lead < baseIndent) {
+            throw new Error(`deft-core-guard workflow line ${index + 1} dedents below run-block base ` +
+                `(indent ${lead} < ${baseIndent}; #3345 YAML load failure class)`);
+        }
+    }
+}
 /**
  * Embedded python3 content check for package.json / lockfiles when co-travelling
  * with .deft/core/** (#3193). Mirrors TS `isUpgradePinPathContentAllowed`.
  * Uses a single-quoted heredoc so GHA does not interpolate shell variables
  * inside the Python source (BASE/HEAD are argv).
+ *
+ * Every emitted line is indented to {@link CORE_GUARD_RUN_INDENT} so the YAML
+ * `run: |` block stays intact (#3345). After GHA strips the common indent, the
+ * shell heredoc body reaches python3 with correct relative indentation.
  */
 function coreGuardPinContentPython() {
     // Keep this compact: deposited into every consumer workflow on init/update.
-    return [
-        '          python3 - "$BASE_SHA" "$HEAD_SHA" <<\'PY\'',
+    const pyBody = [
         "import json, re, subprocess, sys",
         "base_sha, head_sha = sys.argv[1], sys.argv[2]",
         "def git_show(sha, path):",
@@ -766,7 +816,31 @@ function coreGuardPinContentPython() {
         "    print('\\n'.join(bad))",
         "    sys.exit(1)",
         "print('OK: package/lock content is Directive pin unit (#3193).')",
-        "PY",
+    ];
+    const run = CORE_GUARD_RUN_INDENT;
+    return [
+        `${run}python3 - "$BASE_SHA" "$HEAD_SHA" <<'PY'`,
+        ...pyBody.map((line) => `${run}${line}`),
+        `${run}PY`,
+    ].join("\n");
+}
+/**
+ * Shell that materializes the installer-managed allowlist as one ERE per line
+ * and filters "app" paths with `grep -vE -f` (#3345 — avoids a ~5k-char line
+ * that contributed to invalid workflow load). Semantics match the prior
+ * single-alternation ERE (OR of all matchers).
+ */
+function coreGuardAllowlistShell() {
+    const run = CORE_GUARD_RUN_INDENT;
+    const patterns = installerManagedGuardErePatterns();
+    return [
+        `${run}# Installer-managed allowlist — one ERE per line (#3345 loadable YAML)`,
+        `${run}allowlist=$(mktemp)`,
+        `${run}trap 'rm -f "$allowlist"' EXIT`,
+        `${run}cat > "$allowlist" <<'ALLOW'`,
+        ...patterns.map((p) => `${run}${p}`),
+        `${run}ALLOW`,
+        `${run}app=$(printf '%s\\n' "$changed" | grep -vE '^\\.deft/core/' | grep -vE -f "$allowlist" | grep -v '^$' || true)`,
     ].join("\n");
 }
 function coreGuardWorkflowContent() {
@@ -775,7 +849,7 @@ function coreGuardWorkflowContent() {
     const baseSha = githubActionsExpr("github.event.pull_request.base.sha");
     const headSha = githubActionsExpr("github.event.pull_request.head.sha");
     return ("name: deft-core-guard\n\n" +
-        "# Deft framework guard (#1430 / #3127 / #3193): a single PR should not mix changes to the\n" +
+        "# Deft framework guard (#1430 / #3127 / #3193 / #3345): a single PR should not mix changes to the\n" +
         "# vendored framework payload (.deft/core/**) with true application/product files.\n" +
         "# One upgrade PR MAY include deposit + installer-managed paths + package.json pin/lock\n" +
         "# + .deft/GENERATION.json when package.json is @deftai/directive* dependency-key pin-only\n" +
@@ -803,9 +877,7 @@ function coreGuardWorkflowContent() {
         '          echo "Changed files:"\n' +
         '          echo "$changed"\n' +
         "          core=$(printf '%s\\n' \"$changed\" | grep -E '^\\.deft/core/' || true)\n" +
-        "          app=$(printf '%s\\n' \"$changed\" | grep -vE '^\\.deft/core/' | grep -vE '" +
-        installerManagedGuardEre() +
-        "' | grep -v '^$' || true)\n" +
+        `${coreGuardAllowlistShell()}\n` +
         '          if [ -n "$core" ] && [ -n "$app" ]; then\n' +
         '            echo "::error title=deft-core guard (#1430)::This PR changes the vendored framework payload (.deft/core/**) AND non-framework files. Split the framework update into its own PR."\n' +
         '            echo "--- framework (.deft/core/**) changes ---"; printf \'%s\\n\' "$core"\n' +
@@ -951,6 +1023,7 @@ export function ensureCodeqlPathsIgnore(projectDir, io) {
 export function ensureCoreGuardWorkflow(projectDir, io) {
     const path = projectionTarget(projectDir, CORE_GUARD_WORKFLOW_REL);
     const desired = coreGuardWorkflowContent();
+    assertCoreGuardWorkflowLoadable(desired);
     if (existsSync(path)) {
         const existing = readFileSync(path, "utf8");
         if (!existing.includes("name: deft-core-guard")) {

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

@@ -62,6 +62,12 @@ export interface EvaluateVerifyAcOptions extends EvaluateLiteralAcceptanceOption
      * 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.
@@ -71,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

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

@@ -8,7 +8,7 @@
  * 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 { 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 +26,11 @@ 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,
+    };
     const acceptance = readPlanAcceptance(plan);
     const schemaErrors = validatePlanAcceptance(plan.acceptance ?? acceptance);
     // Only hard-fail schema when an explicit plan.acceptance object exists.
@@ -41,9 +46,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 +56,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 +70,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 +78,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 +100,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 +120,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) {
@@ -242,6 +252,7 @@ function applyOracle(result, options) {
             projectRoot,
             runs: gated.runs,
             env: options.env,
+            scopeKey: options.oracleScopeKey,
         });
     }
     let next = gated;
@@ -324,11 +335,36 @@ 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 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, {
+        ...options,
+        skipAcceptanceEmit: true,
+        oracleScopeKey,
+    });
     const banked = maybeAttachAcPassBank(result, plan, abs, options);
-    emitAcceptanceOutcome(banked, options, resolve(options.projectRoot ?? process.cwd()));
+    emitAcceptanceOutcome(banked, options, 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, 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 { 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/verify-ac/evaluate.d.ts

@@ -27,6 +27,16 @@ export interface OracleIntegrityResultFields {
     readonly code: number;
     readonly message: string;
 }
+/** Stable prefix for product-oracle check ids emitted by verify:ac (#3322 / #3337). */
+export declare const VERIFY_AC_CHECK_ID_PREFIX = "verify:ac";
+/**
+ * Namespace product-oracle check_id per active scope (#3337).
+ *
+ * Same-session multi-active verify:ac must not pair fail/pass across briefs.
+ * Prefer plan.id or xBRIEF path as scopeKey; empty → global fallback `verify:ac`
+ * (unknown-scope single-brief / tests without a plan).
+ */
+export declare function verifyAcCheckId(scopeKey?: string | null): string;
 /** Test seam: isolate stdout-dest buffer across cases. */
 export declare function resetInProcessVerificationBuffer(): void;
 /**
@@ -34,12 +44,20 @@ export declare function resetInProcessVerificationBuffer(): void;
  * Fail-open: missing dest / write errors never change the AC result.
  * Stdout dest also appends to the same-process buffer so evaluate can
  * inspect this invocation without re-reading a file.
+ * check_id is namespaced per active scope when scopeKey is provided (#3337).
  */
 export declare function emitVerifyAcAttempts(options: {
     readonly projectRoot: string;
     readonly runs: readonly LiteralAcceptanceRunResult[];
     readonly env?: NodeJS.ProcessEnv;
     readonly sessionId?: string;
+    /**
+     * Active scope identity (plan.id or xBRIEF path stem). When set, check_id
+     * becomes `verify:ac/<scopeKey>` so multi-active sessions do not false-deny (#3337).
+     */
+    readonly scopeKey?: string | null;
+    /** Full check_id override (tests). Wins over scopeKey when non-empty. */
+    readonly checkId?: string | null;
     /** stdout seam (tests). */
     readonly writeStdout?: (line: string) => void;
 }): void;

package/dist/verify-ac/evaluate.js

@@ -16,7 +16,24 @@ function formatUnresolved(flag) {
     return (`check_id=${flag.check_id} fail method=${flag.failed_method} ` +
         `then pass method=${flag.passed_method} without independent re-derivation`);
 }
-const VERIFY_AC_CHECK_ID = "verify:ac";
+/** Stable prefix for product-oracle check ids emitted by verify:ac (#3322 / #3337). */
+export const VERIFY_AC_CHECK_ID_PREFIX = "verify:ac";
+/**
+ * Namespace product-oracle check_id per active scope (#3337).
+ *
+ * Same-session multi-active verify:ac must not pair fail/pass across briefs.
+ * Prefer plan.id or xBRIEF path as scopeKey; empty → global fallback `verify:ac`
+ * (unknown-scope single-brief / tests without a plan).
+ */
+export function verifyAcCheckId(scopeKey) {
+    const key = typeof scopeKey === "string" ? scopeKey.trim() : "";
+    if (key.length === 0) {
+        return VERIFY_AC_CHECK_ID_PREFIX;
+    }
+    // Keep pairing keys readable; strip control chars that would corrupt JSONL.
+    const safe = key.replace(/[\0\n\r]/g, "_");
+    return `${VERIFY_AC_CHECK_ID_PREFIX}/${safe}`;
+}
 /** Same-process verification JSONL when dest is stdout (`-`). */
 const inProcessVerificationLines = [];
 let inProcessStdoutSessionId;
@@ -36,6 +53,7 @@ function inProcessVerificationText() {
  * Fail-open: missing dest / write errors never change the AC result.
  * Stdout dest also appends to the same-process buffer so evaluate can
  * inspect this invocation without re-reading a file.
+ * check_id is namespaced per active scope when scopeKey is provided (#3337).
  */
 export function emitVerifyAcAttempts(options) {
     if (options.runs.length === 0) {
@@ -57,6 +75,10 @@ export function emitVerifyAcAttempts(options) {
                 sessionId = randomUUID();
             }
         }
+        const explicitCheck = typeof options.checkId === "string" && options.checkId.trim().length > 0
+            ? options.checkId.trim()
+            : null;
+        const checkId = explicitCheck ?? verifyAcCheckId(options.scopeKey);
         const emitter = new RunSummaryEmitter({
             projectRoot,
             sessionId,
@@ -65,7 +87,7 @@ export function emitVerifyAcAttempts(options) {
         });
         for (const run of options.runs) {
             const emitted = emitter.emitVerification({
-                check_id: VERIFY_AC_CHECK_ID,
+                check_id: checkId,
                 method_fingerprint: `${run.command}\0${run.cwd}`,
                 outcome: run.ok ? "pass" : "fail",
             });

package/dist/verify-ac/index.d.ts

@@ -5,6 +5,6 @@
  * by editing the comparison. Deterministic surface is the flagged event.
  */
 export { type AcceptanceClause, type AcceptanceClauseReading, type ClauseOutcome, type ClauseWalkReport, type ClauseWalkResult, deriveAcceptanceClauses, formatClauseWalkMessage, isScratchArtifactPath, readAcceptanceClauses, serializeAcceptanceClauses, stampDerivedClausesOnAcceptance, walkAcceptanceClauses, } from "./clauses.js";
-export { type EvaluateProductOracleIntegrityOptions, emitVerifyAcAttempts, evaluateProductOracleIntegrity, mergeOracleVerdict, type OracleIntegrityResultFields, type ProductOracleIntegrityVerdict, } from "./evaluate.js";
+export { type EvaluateProductOracleIntegrityOptions, emitVerifyAcAttempts, evaluateProductOracleIntegrity, mergeOracleVerdict, type OracleIntegrityResultFields, type ProductOracleIntegrityVerdict, VERIFY_AC_CHECK_ID_PREFIX, verifyAcCheckId, } from "./evaluate.js";
 export { type FlaggedMethodChangePass, flagPassAfterFailFromJsonl, flagPassAfterFailWithMethodChange, readVerificationAttempts, unresolvedMethodChangePasses, type VerificationAttempt, } from "./flag.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/verify-ac/index.js

@@ -5,6 +5,6 @@
  * by editing the comparison. Deterministic surface is the flagged event.
  */
 export { deriveAcceptanceClauses, formatClauseWalkMessage, isScratchArtifactPath, readAcceptanceClauses, serializeAcceptanceClauses, stampDerivedClausesOnAcceptance, walkAcceptanceClauses, } from "./clauses.js";
-export { emitVerifyAcAttempts, evaluateProductOracleIntegrity, mergeOracleVerdict, } from "./evaluate.js";
+export { emitVerifyAcAttempts, evaluateProductOracleIntegrity, mergeOracleVerdict, VERIFY_AC_CHECK_ID_PREFIX, verifyAcCheckId, } from "./evaluate.js";
 export { flagPassAfterFailFromJsonl, flagPassAfterFailWithMethodChange, readVerificationAttempts, unresolvedMethodChangePasses, } from "./flag.js";
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.102.0",
+  "version": "0.103.0",
   "description": "TypeScript engine core for the Directive framework.",
   "license": "MIT",
   "type": "module",
@@ -382,8 +382,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-content": "^0.102.0",
-    "@deftai/directive-types": "^0.102.0",
+    "@deftai/directive-content": "^0.103.0",
+    "@deftai/directive-types": "^0.103.0",
     "archiver": "^8.0.0"
   },
   "scripts": {