@deftai/directive-core 0.91.0 → 0.92.0

package/dist/swarm/finalize-cohort.js

@@ -1,8 +1,11 @@
-import { existsSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { evaluate as evaluateBranchPolicy } from "../branch/evaluate.js";
+import { extractIssueRef } from "../capacity/backfill.js";
 import { resolveLifecycleRoot } from "../layout/resolve.js";
+import { resolveDeliveryBranch } from "../policy/delivery-branch.js";
 import { defaultRunGh, fetchClosingIssuesReferences } from "../pr-protected-issues/gh.js";
+import { classifyStoredDeliveryDisposition, evidenceFromPrPayload, verifyDeliveryAncestry, } from "../scope/delivery-evidence.js";
 import { completeCohort } from "./complete-cohort.js";
 import { EXIT_CONFIG_ERROR, EXIT_GATE_FAILED, EXIT_OK } from "./constants.js";
 import { completedBriefReferencesIssue, resolveStories } from "./launch.js";
@@ -55,45 +58,73 @@ function parseRepo(repo) {
     }
     return { owner: repo.slice(0, slash), name: repo.slice(slash + 1) };
 }
-function fetchPrMergedAt(prNumber, repo, runGh) {
+function fetchPrDeliverySnapshot(prNumber, repo, deliveryBranch, runGh) {
     const parsed = parseRepo(repo);
     if (parsed === null) {
-        return { mergedAt: null, error: `invalid --repo value: ${JSON.stringify(repo)}` };
+        return { snapshot: null, error: `invalid --repo value: ${JSON.stringify(repo)}` };
     }
     const path = `repos/${parsed.owner}/${parsed.name}/pulls/${prNumber}`;
     const result = runGh(["gh", "api", path]);
     if (result.returncode !== 0) {
         return {
-            mergedAt: null,
+            snapshot: null,
             error: `gh api ${path} failed: ${result.stderr.trim() || result.stdout.trim()}`,
         };
     }
     try {
-        const parsed = JSON.parse(result.stdout);
-        if (parsed === null || typeof parsed !== "object") {
+        const body = JSON.parse(result.stdout);
+        if (body === null || typeof body !== "object") {
             return {
-                mergedAt: null,
+                snapshot: null,
                 error: `unexpected gh api response for PR #${prNumber}: not a JSON object`,
             };
         }
-        const payload = parsed;
+        const payload = body;
         const mergedAt = payload.merged_at;
-        if (mergedAt === null) {
-            return { mergedAt: null, error: `PR #${prNumber} is not merged yet.` };
+        if (mergedAt === null || typeof mergedAt !== "string" || mergedAt.length === 0) {
+            return { snapshot: null, error: `PR #${prNumber} is not merged yet.` };
         }
-        if (typeof mergedAt !== "string" || mergedAt.length === 0) {
-            return { mergedAt: null, error: `PR #${prNumber} is not merged yet.` };
-        }
-        return { mergedAt, error: null };
+        const base = payload.base;
+        const prBase = typeof base === "object" &&
+            base !== null &&
+            !Array.isArray(base) &&
+            typeof base.ref === "string"
+            ? String(base.ref)
+            : null;
+        const mergeCommitSha = typeof payload.merge_commit_sha === "string" && payload.merge_commit_sha.length > 0
+            ? payload.merge_commit_sha
+            : null;
+        const evidence = evidenceFromPrPayload(payload, prNumber, repo, deliveryBranch);
+        return {
+            snapshot: {
+                mergedAt,
+                prBase,
+                mergeCommitSha,
+                payload,
+                evidence,
+            },
+            error: null,
+        };
     }
     catch (exc) {
         const message = exc instanceof Error ? exc.message : String(exc);
         return {
-            mergedAt: null,
+            snapshot: null,
             error: `failed to parse gh api response for PR #${prNumber}: ${message}`,
         };
     }
 }
+/** Adapt swarm runText to the session GitRunner shape used by delivery-evidence. */
+function asGitRunner(runGit) {
+    return (projectRoot, args) => {
+        const result = runGit(["git", ...args], { cwd: projectRoot });
+        return {
+            code: result.returncode,
+            stdout: result.stdout,
+            stderr: result.stderr,
+        };
+    };
+}
 function fetchClosingIssues(prNumber, repo, runGh) {
     const parsed = parseRepo(repo);
     if (parsed === null) {
@@ -280,14 +311,34 @@ export function finalizeCohort(args) {
     const projectRoot = resolve(args.projectRoot ?? process.cwd());
     const runGh = args.runGh ?? defaultRunGh;
     const runGit = args.runGit ?? runText;
+    const gitRunner = asGitRunner(runGit);
     const prNumbers = [...(args.prNumbers ?? [])].sort((a, b) => a - b);
     const storyTokens = splitCsv(args.storyTokens ?? []);
     const repo = args.repo ?? process.env.GH_REPO ?? null;
+    // baseBranch is for the lifecycle sweep PR only — not delivery proof (#3041).
     const baseBranch = args.baseBranch ?? "master";
     const dryRun = args.dryRun ?? false;
     const noCommit = args.noCommit ?? false;
     const noOpenPr = args.noOpenPr ?? false;
     const errors = [];
+    const deliveryErrors = [];
+    // plan.policy.deliveryBranch (or git default) is SoT. CLI may only fill when policy is
+    // not typed — never redefine a typed delivery branch to an integration target (#3041).
+    const policyDelivery = resolveDeliveryBranch(projectRoot, gitRunner);
+    const cliDelivery = args.deliveryBranch !== null &&
+        args.deliveryBranch !== undefined &&
+        args.deliveryBranch.trim().length > 0
+        ? args.deliveryBranch.trim()
+        : null;
+    if (cliDelivery !== null && cliDelivery !== policyDelivery.branch) {
+        if (policyDelivery.source === "typed") {
+            errors.push(`--delivery-branch '${cliDelivery}' conflicts with plan.policy.deliveryBranch ` +
+                `'${policyDelivery.branch}'. Typed policy wins; do not redefine delivery via CLI (#3041).`);
+        }
+    }
+    const deliveryBranch = policyDelivery.source === "typed"
+        ? policyDelivery.branch
+        : (cliDelivery ?? policyDelivery.branch);
     if (!existsSync(projectRoot)) {
         return buildResponse({
             projectRoot,
@@ -300,6 +351,8 @@ export function finalizeCohort(args) {
             commitSha: null,
             branch: null,
             prUrl: null,
+            deliveryBranch,
+            deliveryErrors: [],
             errors: [`project root does not exist: ${projectRoot}`],
             warnings: [],
             ok: false,
@@ -319,6 +372,8 @@ export function finalizeCohort(args) {
             commitSha: null,
             branch: null,
             prUrl: null,
+            deliveryBranch,
+            deliveryErrors: [],
             errors: [`no xbrief/ directory under project root: ${projectRoot}`],
             warnings: [],
             ok: false,
@@ -327,27 +382,63 @@ export function finalizeCohort(args) {
         });
     }
     const closingIssues = new Set();
-    if (prNumbers.length > 0) {
+    /** Per-closing-issue delivery evidence so multi-PR cohorts do not collapse provenance (#3041). */
+    const evidenceByIssue = new Map();
+    const validatedPrs = [];
+    if (prNumbers.length > 0 && errors.length === 0) {
         if (repo === null || repo.length === 0) {
             errors.push("--repo OWNER/REPO is required when --pr is supplied (or set $GH_REPO).");
         }
         else {
             for (const prNumber of prNumbers) {
-                const merged = fetchPrMergedAt(prNumber, repo, runGh);
-                if (merged.error !== null) {
-                    errors.push(merged.error);
+                const fetched = fetchPrDeliverySnapshot(prNumber, repo, deliveryBranch, runGh);
+                if (fetched.error !== null || fetched.snapshot === null) {
+                    errors.push(fetched.error ?? `PR #${prNumber}: delivery snapshot unavailable`);
                     continue;
                 }
+                const snap = fetched.snapshot;
+                // base.ref must equal configured deliveryBranch — integration bases fail closed (#3041).
+                if (snap.prBase === null || snap.prBase.length === 0) {
+                    deliveryErrors.push(`PR #${prNumber}: missing base.ref; cannot verify delivery branch (#3041).`);
+                    continue;
+                }
+                if (snap.prBase !== deliveryBranch) {
+                    deliveryErrors.push(`PR #${prNumber}: base.ref '${snap.prBase}' is not the delivery branch ` +
+                        `'${deliveryBranch}'. Merged-to-integration is not delivery evidence (#3041). ` +
+                        `(Note: --base-branch only controls the lifecycle sweep PR target, not delivery.)`);
+                    continue;
+                }
+                if (snap.mergeCommitSha === null) {
+                    deliveryErrors.push(`PR #${prNumber}: missing merge_commit_sha; cannot prove delivery ancestry (#3041).`);
+                    continue;
+                }
+                // Refresh remote delivery ref and require merge commit ancestry (#3041).
+                const ancestry = verifyDeliveryAncestry(projectRoot, snap.mergeCommitSha, deliveryBranch, gitRunner);
+                if (!ancestry.ok) {
+                    deliveryErrors.push(`PR #${prNumber}: ${ancestry.error}`);
+                    continue;
+                }
+                validatedPrs.push(prNumber);
+                const prEvidence = {
+                    ...snap.evidence,
+                    deliveryBranch,
+                    deliveryCommit: ancestry.remoteTip,
+                    verifier: "swarm:finalize-cohort",
+                };
                 const closing = fetchClosingIssues(prNumber, repo, runGh);
                 if (closing.error !== null) {
                     errors.push(closing.error);
                 }
                 for (const issue of closing.issues) {
                     closingIssues.add(issue);
+                    evidenceByIssue.set(issue, prEvidence);
                 }
             }
         }
     }
+    if (deliveryErrors.length > 0) {
+        errors.push(...deliveryErrors);
+    }
     if (storyTokens.length === 0 && closingIssues.size === 0) {
         errors.push("empty cohort: pass --pr <numbers> and/or --stories <ids|paths>.");
     }
@@ -393,8 +484,33 @@ export function finalizeCohort(args) {
         const completedBrief = completedBriefReferencesIssue(projectRoot, issue);
         const issueClosed = completedBrief || fetchIssueClosed(issue, repo, runGh);
         if (completedBrief || issueClosed) {
+            let dispositionNote = "";
+            if (completedBrief) {
+                try {
+                    const completedDir = resolve(projectRoot, "xbrief", "completed");
+                    // Best-effort surface of legacy delivery disposition for completed briefs (#3041).
+                    if (existsSync(completedDir)) {
+                        for (const name of readdirSync(completedDir)) {
+                            if (!name.endsWith(".json"))
+                                continue;
+                            const raw = JSON.parse(readFileSync(resolve(completedDir, name), "utf8"));
+                            if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+                                continue;
+                            const plan = raw.plan;
+                            if (typeof plan !== "object" || plan === null || Array.isArray(plan))
+                                continue;
+                            const disposition = classifyStoredDeliveryDisposition(plan);
+                            dispositionNote = ` deliveryDisposition=${disposition}`;
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    /* best-effort disposition surfacing for legacy completed records */
+                }
+            }
             const reason = completedBrief
-                ? "a completed brief already exists"
+                ? `a completed brief already exists${dispositionNote}`
                 : "the issue is already closed";
             warnings.push(`#${issue}: no active story references this closing issue; skipped (${reason}).`);
         }
@@ -417,17 +533,78 @@ export function finalizeCohort(args) {
             commitSha: null,
             branch: null,
             prUrl: null,
+            deliveryBranch,
+            deliveryErrors,
             errors,
             warnings,
             ok: cleanNoop,
             emitJson: args.emitJson ?? false,
             exitCode: cleanNoop
                 ? EXIT_OK
-                : errors.some((e) => e.includes("not merged"))
+                : errors.some((e) => e.includes("not merged") || e.includes("delivery"))
                     ? EXIT_GATE_FAILED
                     : EXIT_CONFIG_ERROR,
         });
     }
+    // When --pr was supplied, every PR must pass delivery validation before sweep (#3041).
+    if (prNumbers.length > 0 && validatedPrs.length !== prNumbers.length && errors.length > 0) {
+        return buildResponse({
+            projectRoot,
+            dryRun,
+            noCommit,
+            prNumbers,
+            storyPaths,
+            closingIssues: [...closingIssues],
+            sweep: null,
+            commitSha: null,
+            branch: null,
+            prUrl: null,
+            deliveryBranch,
+            deliveryErrors,
+            errors,
+            warnings,
+            ok: false,
+            emitJson: args.emitJson ?? false,
+            exitCode: EXIT_GATE_FAILED,
+        });
+    }
+    // Stories without PR-backed delivery evidence still hit the complete gate; if
+    // only --stories was supplied, complete-cohort fails closed for code-bearing
+    // scopes unless callers pass evidence (finalize requires --pr for delivery).
+    if (prNumbers.length === 0 && evidenceByIssue.size === 0) {
+        warnings.push("No --pr supplied: code-bearing stories require delivery evidence or " +
+            "will fail closed at scope:complete (#3041).");
+    }
+    // Bind each story path to the evidence of its closing-issue PR (no cohort-wide collapse).
+    const evidenceByPath = new Map();
+    for (const storyPath of storyPaths) {
+        try {
+            const raw = JSON.parse(readFileSync(storyPath, "utf8"));
+            if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+                continue;
+            }
+            const plan = raw.plan;
+            if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+                continue;
+            }
+            const [, issueNum] = extractIssueRef(plan);
+            if (issueNum !== null) {
+                const bound = evidenceByIssue.get(issueNum);
+                if (bound !== undefined) {
+                    evidenceByPath.set(resolve(storyPath), bound);
+                }
+            }
+        }
+        catch {
+            /* unreadable brief — complete gate fails closed later if code-bearing */
+        }
+    }
+    // Single-PR cohorts: every story inherits that PR's evidence when issue binding misses
+    // (operator --stories + one --pr is the common finalize path).
+    let defaultEvidence = null;
+    if (validatedPrs.length === 1 && evidenceByIssue.size > 0) {
+        defaultEvidence = evidenceByIssue.values().next().value ?? null;
+    }
     let commitSha = null;
     let branch = null;
     let prUrl = null;
@@ -447,11 +624,21 @@ export function finalizeCohort(args) {
             }
         }
     }
+    const hasDelivery = evidenceByPath.size > 0 || defaultEvidence !== null;
     const sweepResult = completeCohort({
         stories: storyPaths,
         projectRoot,
         dryRun,
         emitJson: false,
+        delivery: hasDelivery
+            ? {
+                evidenceByPath,
+                defaultEvidence,
+                // Ancestry already verified above; avoid double remote fetch on each story.
+                assumeEvidenceValidated: true,
+                verifier: "swarm:finalize-cohort",
+            }
+            : null,
     });
     if (sweepResult.exitCode !== 0) {
         errors.push("cohort completion sweep failed.");
@@ -466,6 +653,8 @@ export function finalizeCohort(args) {
             commitSha: null,
             branch: null,
             prUrl: null,
+            deliveryBranch,
+            deliveryErrors,
             errors,
             warnings,
             ok: false,
@@ -503,6 +692,8 @@ export function finalizeCohort(args) {
         commitSha,
         branch,
         prUrl,
+        deliveryBranch,
+        deliveryErrors,
         errors,
         warnings,
         ok,
@@ -522,6 +713,8 @@ function buildResponse(input) {
         commit_sha: input.commitSha,
         branch: input.branch,
         pr_url: input.prUrl,
+        delivery_branch: input.deliveryBranch,
+        delivery_errors: input.deliveryErrors,
         errors: input.errors,
         warnings: input.warnings,
         ok: input.ok,
@@ -539,6 +732,9 @@ function buildResponse(input) {
             `(${input.storyPaths.length} stor${input.storyPaths.length === 1 ? "y" : "ies"})`,
         `  Project root: ${input.projectRoot}`,
     ];
+    if (input.deliveryBranch !== null) {
+        lines.push(`  Delivery branch: ${input.deliveryBranch}`);
+    }
     if (input.prNumbers.length > 0) {
         lines.push(`  PRs: ${input.prNumbers.map((n) => `#${n}`).join(", ")}`);
     }

package/dist/user-config/experimental-rules.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Safe USER.md Experimental Rules toggle (#46).
+ *
+ * Pure string helpers that add/remove only the three canonical meta-philosophy
+ * reference lines (SOUL / morals / code-field). Personal and Defaults section
+ * bodies are never rewritten — only the `## Experimental Rules` region changes.
+ *
+ * Detection matches lines under `## Experimental Rules` that contain the deposit
+ * path (`meta/SOUL.md`, …); enable writes the canonical setup-skill bullet.
+ * Custom bullets for other topics in the same section are preserved.
+ */
+export type ExperimentalMetaId = "soul" | "morals" | "code-field";
+export interface ExperimentalMetaEntry {
+    readonly id: ExperimentalMetaId;
+    /** Path fragment matched in USER.md lines (e.g. `meta/SOUL.md`). */
+    readonly path: string;
+    /** Canonical bullet written when enabling. */
+    readonly line: string;
+}
+/** Canonical Experimental Rules entries (setup Phase 1 steps 5a–5c). */
+export declare const EXPERIMENTAL_META_ENTRIES: readonly ExperimentalMetaEntry[];
+export type ExperimentalRulesState = Record<ExperimentalMetaId, boolean>;
+/**
+ * Parse on/off state for the three experimental meta entries.
+ * A path is ON only when a line under `## Experimental Rules` mentions it —
+ * mentions in Personal/Defaults/prose do not count (writes are section-scoped).
+ */
+export declare function parseExperimentalRulesState(userMdText: string): ExperimentalRulesState;
+/**
+ * Apply desired Experimental Rules on/off state.
+ *
+ * - Only mutates the `## Experimental Rules` region (or inserts/removes it).
+ * - Personal / Defaults content is left byte-identical outside that region.
+ * - Enabling uses the canonical setup-skill lines; disabling drops path matches.
+ * - Custom non-meta bullets under the section are preserved.
+ * - When all three are off and no custom bullets remain, the section is removed.
+ */
+export declare function applyExperimentalRulesState(userMdText: string, desired: ExperimentalRulesState): string;
+/**
+ * Toggle a single experimental meta entry; leave the other two unchanged.
+ */
+export declare function setExperimentalRule(userMdText: string, id: ExperimentalMetaId, enabled: boolean): string;
+//# sourceMappingURL=experimental-rules.d.ts.map

package/dist/user-config/experimental-rules.js

@@ -0,0 +1,162 @@
+/**
+ * Safe USER.md Experimental Rules toggle (#46).
+ *
+ * Pure string helpers that add/remove only the three canonical meta-philosophy
+ * reference lines (SOUL / morals / code-field). Personal and Defaults section
+ * bodies are never rewritten — only the `## Experimental Rules` region changes.
+ *
+ * Detection matches lines under `## Experimental Rules` that contain the deposit
+ * path (`meta/SOUL.md`, …); enable writes the canonical setup-skill bullet.
+ * Custom bullets for other topics in the same section are preserved.
+ */
+/** Canonical Experimental Rules entries (setup Phase 1 steps 5a–5c). */
+export const EXPERIMENTAL_META_ENTRIES = [
+    {
+        id: "soul",
+        path: "meta/SOUL.md",
+        line: "- ! Use meta/SOUL.md for strategic context and purpose-driven guidance",
+    },
+    {
+        id: "morals",
+        path: "meta/morals.md",
+        line: "- ! Use meta/morals.md for ethical AI development principles",
+    },
+    {
+        id: "code-field",
+        path: "meta/code-field.md",
+        line: "- ~ Use meta/code-field.md for advanced architecture patterns",
+    },
+];
+const SECTION_HEADING = "## Experimental Rules";
+function detectNewline(text) {
+    return text.includes("\r\n") ? "\r\n" : "\n";
+}
+function lineMentionsPath(line, path) {
+    return line.includes(path);
+}
+function findExperimentalSection(text) {
+    const re = /^## Experimental Rules[ \t]*\r?\n?/m;
+    const match = re.exec(text);
+    if (!match || match.index === undefined) {
+        return null;
+    }
+    const start = match.index;
+    const afterHeading = start + match[0].length;
+    const rest = text.slice(afterHeading);
+    // Next H2 or a horizontal rule at line start ends the section.
+    const next = /^(## |---[ \t]*$)/m.exec(rest);
+    const end = next && next.index !== undefined ? afterHeading + next.index : text.length;
+    return {
+        start,
+        end,
+        full: text.slice(start, end),
+        body: text.slice(afterHeading, end),
+    };
+}
+/**
+ * Parse on/off state for the three experimental meta entries.
+ * A path is ON only when a line under `## Experimental Rules` mentions it —
+ * mentions in Personal/Defaults/prose do not count (writes are section-scoped).
+ */
+export function parseExperimentalRulesState(userMdText) {
+    const state = {
+        soul: false,
+        morals: false,
+        "code-field": false,
+    };
+    const section = findExperimentalSection(userMdText);
+    if (!section) {
+        return state;
+    }
+    for (const line of section.body.split(/\r?\n/)) {
+        for (const entry of EXPERIMENTAL_META_ENTRIES) {
+            if (lineMentionsPath(line, entry.path)) {
+                state[entry.id] = true;
+            }
+        }
+    }
+    return state;
+}
+/**
+ * Build section body lines: preserve non-meta custom bullets; apply desired
+ * on/off for the three canonical paths; stable order soul → morals → code-field.
+ */
+function buildSectionBody(existingBody, desired, nl) {
+    const rawLines = existingBody.split(/\r?\n/);
+    const custom = [];
+    for (const line of rawLines) {
+        if (line.trim() === "") {
+            continue;
+        }
+        const isMeta = EXPERIMENTAL_META_ENTRIES.some((e) => lineMentionsPath(line, e.path));
+        if (!isMeta) {
+            custom.push(line);
+        }
+    }
+    const metaLines = EXPERIMENTAL_META_ENTRIES.filter((e) => desired[e.id]).map((e) => e.line);
+    const bullets = [...metaLines, ...custom];
+    if (bullets.length === 0) {
+        return "";
+    }
+    // Heading + blank line + bullets + trailing blank line for clean separation.
+    return `${SECTION_HEADING}${nl}${nl}${bullets.join(nl)}${nl}`;
+}
+/**
+ * Insert a new Experimental Rules section before the trailing `---` / Note
+ * block when present; otherwise append after the last non-empty content.
+ */
+function insertSection(text, section, nl) {
+    // Prefer before the trailing horizontal rule that precedes the USER.md Note
+    // block (allow blank lines between `---` and `**Note**`).
+    const noteRe = /\r?\n---[ \t]*\r?\n(?:[ \t]*\r?\n)*[ \t]*\*\*Note\*\*/;
+    const noteMatch = noteRe.exec(text);
+    if (noteMatch && noteMatch.index !== undefined) {
+        const before = text.slice(0, noteMatch.index).replace(/[ \t]+$/u, "");
+        const after = text.slice(noteMatch.index);
+        const sep = before.endsWith(nl) ? nl : `${nl}${nl}`;
+        return `${before}${sep}${section.replace(/\s+$/u, "")}${after}`;
+    }
+    const trimmed = text.replace(/\s+$/u, "");
+    return `${trimmed}${nl}${nl}${section.replace(/\s+$/u, "")}${nl}`;
+}
+/**
+ * Apply desired Experimental Rules on/off state.
+ *
+ * - Only mutates the `## Experimental Rules` region (or inserts/removes it).
+ * - Personal / Defaults content is left byte-identical outside that region.
+ * - Enabling uses the canonical setup-skill lines; disabling drops path matches.
+ * - Custom non-meta bullets under the section are preserved.
+ * - When all three are off and no custom bullets remain, the section is removed.
+ */
+export function applyExperimentalRulesState(userMdText, desired) {
+    const nl = detectNewline(userMdText);
+    const sectionText = buildSectionBody(findExperimentalSection(userMdText)?.body ?? "", desired, nl);
+    const existing = findExperimentalSection(userMdText);
+    if (existing) {
+        if (!sectionText) {
+            // Remove section; tidy surrounding blank lines.
+            const before = userMdText.slice(0, existing.start).replace(/[ \t]+$/u, "");
+            let after = userMdText.slice(existing.end);
+            // Collapse to at most two newlines at the join.
+            const beforeCore = before.replace(/(\r?\n){2,}$/u, nl);
+            after = after.replace(/^(\r?\n)+/u, nl);
+            if (after.startsWith("---") || after.startsWith("## ")) {
+                return `${beforeCore.replace(/(\r?\n)+$/u, nl)}${nl}${after}`;
+            }
+            return `${beforeCore}${after}`;
+        }
+        return userMdText.slice(0, existing.start) + sectionText + userMdText.slice(existing.end);
+    }
+    if (!sectionText) {
+        return userMdText;
+    }
+    return insertSection(userMdText, sectionText, nl);
+}
+/**
+ * Toggle a single experimental meta entry; leave the other two unchanged.
+ */
+export function setExperimentalRule(userMdText, id, enabled) {
+    const current = parseExperimentalRulesState(userMdText);
+    return applyExperimentalRulesState(userMdText, { ...current, [id]: enabled });
+}
+//# sourceMappingURL=experimental-rules.js.map

package/dist/user-config/index.d.ts

@@ -1,2 +1,3 @@
+export * from "./experimental-rules.js";
 export * from "./resolve-user-md.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/user-config/index.js

@@ -1,2 +1,3 @@
+export * from "./experimental-rules.js";
 export * from "./resolve-user-md.js";
 //# sourceMappingURL=index.js.map

package/dist/verify-source/contained-writes.js

@@ -59,7 +59,7 @@ export const CONTAINED_WRITES_ALLOWLIST = [
     "packages/core/src/intake/issue-ingest.ts",
     "packages/core/src/intake/reconcile-issues.ts",
     "packages/core/src/issue-sync/sync-from-xbrief.ts",
-    "packages/core/src/orchestration/probe-session.ts",
+    // probe-session.ts removed from allowlist after #3042 contained writeSession.
     "packages/core/src/orchestration/verify-judgment-gates.ts",
     "packages/core/src/platform/changelog-cli.ts",
     "packages/core/src/release/gh.ts",

package/package.json

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