@deftai/directive-core 0.68.1 → 0.70.0

package/dist/xbrief-migrate/detect.js

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { LEGACY_ARTIFACT_DIR, LEGACY_ARTIFACT_SUFFIX, LEGACY_INFO_ROOT_KEY, LEGACY_VBRIEF_VERSION, MIGRATED_ARTIFACT_DIR, VBRIEF_REFERENCE_PREFIX, } from "./constants.js";
+import { hasVbriefDeprecationMarker, isEffectivelyEmptyDir } from "./fs-helpers.js";
 function isDirectory(path) {
     try {
         return statSync(path).isDirectory();
@@ -78,4 +79,36 @@ export function detectLegacyVbriefLayout(projectRoot) {
     const reasonList = [...reasons];
     return { legacyLayout: reasonList.length > 0, reasons: reasonList };
 }
+/**
+ * Classify the convergence state of the `vbrief/` and `xbrief/` lifecycle roots
+ * so the orchestrator can converge to a single unambiguous root (#2270). Unlike
+ * {@link detectLegacyVbriefLayout} (which only asks "is there anything legacy?"),
+ * this probe distinguishes the ambiguous dual-empty-root case from an already
+ * unambiguous layout, and never falls back to a `run migrate:xbrief` dead end
+ * for a `vbrief/` that is merely an empty leftover.
+ */
+export function detectXbriefConvergence(projectRoot) {
+    const legacyDir = join(projectRoot, LEGACY_ARTIFACT_DIR);
+    const migratedDir = join(projectRoot, MIGRATED_ARTIFACT_DIR);
+    const vbriefPresent = isDirectory(legacyDir);
+    const vbriefHasMarker = vbriefPresent && hasVbriefDeprecationMarker(legacyDir);
+    const vbriefEmpty = vbriefPresent && !vbriefHasMarker && isEffectivelyEmptyDir(legacyDir);
+    const xbriefPresent = isDirectory(migratedDir);
+    const xbriefHasContent = xbriefPresent && !isEffectivelyEmptyDir(migratedDir);
+    let state;
+    if (vbriefHasMarker) {
+        state = "xbrief-marker";
+    }
+    else if (!vbriefPresent) {
+        state = xbriefHasContent ? "xbrief-only" : "none";
+    }
+    else if (vbriefEmpty) {
+        state = "empty-vbrief";
+    }
+    else {
+        // vbrief/ holds real content and carries no marker.
+        state = xbriefHasContent ? "dual-populated" : "legacy-only";
+    }
+    return { state, vbriefPresent, vbriefEmpty, vbriefHasMarker, xbriefPresent, xbriefHasContent };
+}
 //# sourceMappingURL=detect.js.map

package/dist/xbrief-migrate/fs-helpers.d.ts

@@ -1,3 +1,16 @@
 /** True when `path` exists and is a directory; false on any stat error. */
 export declare function isDirectory(path: string): boolean;
+/**
+ * True when `dir` holds no meaningful content at any depth — a "fully migrated"
+ * lifecycle root. Empty subdirectories and VCS placeholder files (`.gitkeep`,
+ * `.keep`) are ignored, so a scaffolded-but-empty `vbrief/proposed/` tree still
+ * counts as empty. A missing directory is trivially empty (#2270).
+ */
+export declare function isEffectivelyEmptyDir(dir: string): boolean;
+/**
+ * True when `dir` carries a deft-written deprecation marker identifying it as a
+ * retained-for-read-compat legacy root rather than an active source of truth
+ * (#2270). Matched on the sentinel so an unrelated `DEPRECATED.md` is ignored.
+ */
+export declare function hasVbriefDeprecationMarker(dir: string): boolean;
 //# sourceMappingURL=fs-helpers.d.ts.map

package/dist/xbrief-migrate/fs-helpers.js

@@ -1,4 +1,6 @@
-import { statSync } from "node:fs";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { VBRIEF_DEPRECATION_MARKER_FILENAME, VBRIEF_DEPRECATION_MARKER_SENTINEL, } from "./constants.js";
 /** True when `path` exists and is a directory; false on any stat error. */
 export function isDirectory(path) {
     try {
@@ -8,4 +10,47 @@ export function isDirectory(path) {
         return false;
     }
 }
+/** Placeholder files that do not count as real content when judging emptiness. */
+const PLACEHOLDER_FILES = new Set([".gitkeep", ".keep"]);
+/**
+ * True when `dir` holds no meaningful content at any depth — a "fully migrated"
+ * lifecycle root. Empty subdirectories and VCS placeholder files (`.gitkeep`,
+ * `.keep`) are ignored, so a scaffolded-but-empty `vbrief/proposed/` tree still
+ * counts as empty. A missing directory is trivially empty (#2270).
+ */
+export function isEffectivelyEmptyDir(dir) {
+    if (!isDirectory(dir)) {
+        return true;
+    }
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isFile()) {
+            if (PLACEHOLDER_FILES.has(entry.name)) {
+                continue;
+            }
+            return false;
+        }
+        // A symlink (to a file or dir) is real content: `isFile`/`isDirectory` both
+        // report false for symlink dirents, so treat it explicitly as non-empty.
+        if (entry.isSymbolicLink()) {
+            return false;
+        }
+        if (entry.isDirectory() && !isEffectivelyEmptyDir(join(dir, entry.name))) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * True when `dir` carries a deft-written deprecation marker identifying it as a
+ * retained-for-read-compat legacy root rather than an active source of truth
+ * (#2270). Matched on the sentinel so an unrelated `DEPRECATED.md` is ignored.
+ */
+export function hasVbriefDeprecationMarker(dir) {
+    try {
+        return readFileSync(join(dir, VBRIEF_DEPRECATION_MARKER_FILENAME), "utf8").includes(VBRIEF_DEPRECATION_MARKER_SENTINEL);
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=fs-helpers.js.map

package/dist/xbrief-migrate/index.d.ts

@@ -1,7 +1,9 @@
 export { detectStaleUnmanagedHeader, type HeaderPatchOutcome, type HeaderRewriteResult, type HeaderTokenReplacement, LEGACY_HEADER_TOKENS, patchAgentsMdHeader, renderHeaderPatchSummary, renderStaleHeaderLine, rewriteUnmanagedHeaderTokens, type StaleHeaderDetection, } from "./agents-header.js";
-export { detectLegacyVbriefLayout, type LegacyVbriefLayoutDetection, } from "./detect.js";
+export { VBRIEF_DEPRECATION_MARKER_BODY, VBRIEF_DEPRECATION_MARKER_FILENAME, VBRIEF_DEPRECATION_MARKER_SENTINEL, } from "./constants.js";
+export { detectLegacyVbriefLayout, detectXbriefConvergence, type LegacyVbriefLayoutDetection, type XbriefConvergenceDetection, type XbriefConvergenceState, } from "./detect.js";
 export { BUILTIN_ALLOW_LIST, type DriftEvaluateOptions, type DriftEvaluateResult, type DriftFinding, type DriftScanMode, evaluateXbriefDrift, LEGACY_REFERENCE_PREFIX, scanCorpusToken, } from "./drift-gate.js";
-export { emitXbriefMigration, runXbriefMigration, runXbriefMigrationCli, type XbriefMigrationArgs, type XbriefMigrationIo, type XbriefMigrationOutcome, } from "./migrate-project.js";
+export { hasVbriefDeprecationMarker, isDirectory, isEffectivelyEmptyDir, } from "./fs-helpers.js";
+export { convergeLegacyVbriefRoot, emitXbriefMigration, runXbriefMigration, runXbriefMigrationCli, type VbriefConvergeAction, type XbriefMigrationArgs, type XbriefMigrationIo, type XbriefMigrationOutcome, } from "./migrate-project.js";
 export { renderXbriefMigrationLine, xbriefMigrationGuidance } from "./signpost.js";
 export { assertFeatureEmissionAllowed, assertLayoutAwareWritePath, FeatureEmissionRejectedError, type JsonObject, type JsonValue, readDeclaredArtifactVersion, resolveLayoutAwareRelativePath, rewriteEmbeddedTokens, SplitLayoutRejectedError, TransformError, transformArtifactV06ToV08, transformArtifactV06ToV08Transactional, } from "./transforms.js";
 export { isPatchOnlyUpgrade, parseSemverPrefix } from "./version.js";

package/dist/xbrief-migrate/index.js

@@ -1,7 +1,9 @@
 export { detectStaleUnmanagedHeader, LEGACY_HEADER_TOKENS, patchAgentsMdHeader, renderHeaderPatchSummary, renderStaleHeaderLine, rewriteUnmanagedHeaderTokens, } from "./agents-header.js";
-export { detectLegacyVbriefLayout, } from "./detect.js";
+export { VBRIEF_DEPRECATION_MARKER_BODY, VBRIEF_DEPRECATION_MARKER_FILENAME, VBRIEF_DEPRECATION_MARKER_SENTINEL, } from "./constants.js";
+export { detectLegacyVbriefLayout, detectXbriefConvergence, } from "./detect.js";
 export { BUILTIN_ALLOW_LIST, evaluateXbriefDrift, LEGACY_REFERENCE_PREFIX, scanCorpusToken, } from "./drift-gate.js";
-export { emitXbriefMigration, runXbriefMigration, runXbriefMigrationCli, } from "./migrate-project.js";
+export { hasVbriefDeprecationMarker, isDirectory, isEffectivelyEmptyDir, } from "./fs-helpers.js";
+export { convergeLegacyVbriefRoot, emitXbriefMigration, runXbriefMigration, runXbriefMigrationCli, } from "./migrate-project.js";
 export { renderXbriefMigrationLine, xbriefMigrationGuidance } from "./signpost.js";
 export { assertFeatureEmissionAllowed, assertLayoutAwareWritePath, FeatureEmissionRejectedError, readDeclaredArtifactVersion, resolveLayoutAwareRelativePath, rewriteEmbeddedTokens, SplitLayoutRejectedError, TransformError, transformArtifactV06ToV08, transformArtifactV06ToV08Transactional, } from "./transforms.js";
 export { isPatchOnlyUpgrade, parseSemverPrefix } from "./version.js";

package/dist/xbrief-migrate/migrate-project.d.ts

@@ -2,11 +2,18 @@ export interface XbriefMigrationArgs {
     readonly projectRoot: string;
     readonly frameworkRoot?: string;
     readonly force?: boolean;
+    /**
+     * Retain a fully-migrated `vbrief/` for read-compatibility behind an explicit
+     * deprecation marker instead of removing it (#2270). Default: remove.
+     */
+    readonly keepLegacy?: boolean;
 }
 export interface XbriefMigrationIo {
     writeOut: (text: string) => void;
     writeErr: (text: string) => void;
 }
+/** How the legacy `vbrief/` root was converged to an unambiguous state (#2270). */
+export type VbriefConvergeAction = "removed" | "marker";
 export type XbriefMigrationOutcome = {
     readonly kind: "noop";
     readonly message: string;
@@ -17,11 +24,26 @@ export type XbriefMigrationOutcome = {
     readonly kind: "migrated";
     readonly backupDir: string;
     readonly files: number;
+} | {
+    readonly kind: "converged";
+    readonly action: VbriefConvergeAction;
+    readonly already: boolean;
+    readonly message: string;
 } | {
     readonly kind: "config";
     readonly message: string;
 };
-/** Core orchestrator for the consumer xbrief rename (#2110). */
+/**
+ * Converge a leftover legacy `vbrief/` root to an unambiguous state (#2270).
+ * An effectively-empty tree is removed by default (single canonical root); a
+ * tree with real content — or an empty tree when `retain` is requested — is
+ * kept for read-compat behind an explicit deprecation marker. Idempotent: a
+ * missing dir or an already-marked dir is a no-op.
+ */
+export declare function convergeLegacyVbriefRoot(projectRoot: string, options: {
+    retain: boolean;
+}): VbriefConvergeAction;
+/** Core orchestrator for the consumer xbrief rename (#2110) + convergence (#2270). */
 export declare function runXbriefMigration(args: XbriefMigrationArgs, _io: XbriefMigrationIo): XbriefMigrationOutcome;
 /** Map a migration outcome to a process exit code and emit operator guidance. */
 export declare function emitXbriefMigration(outcome: XbriefMigrationOutcome, io: XbriefMigrationIo, options?: {

package/dist/xbrief-migrate/migrate-project.js

@@ -3,9 +3,9 @@ import { dirname, join, relative, resolve } from "node:path";
 import { checkGitClean } from "../migrate-preflight/index.js";
 import { agentsRefreshPlan } from "../platform/agents-md.js";
 import { patchAgentsMdHeader, renderHeaderPatchSummary } from "./agents-header.js";
-import { LEGACY_ARTIFACT_DIR, LEGACY_ARTIFACT_SUFFIX, MIGRATED_ARTIFACT_DIR, MIGRATED_ARTIFACT_SUFFIX, } from "./constants.js";
-import { detectLegacyVbriefLayout } from "./detect.js";
-import { isDirectory } from "./fs-helpers.js";
+import { LEGACY_ARTIFACT_DIR, LEGACY_ARTIFACT_SUFFIX, MIGRATED_ARTIFACT_DIR, MIGRATED_ARTIFACT_SUFFIX, VBRIEF_DEPRECATION_MARKER_BODY, VBRIEF_DEPRECATION_MARKER_FILENAME, } from "./constants.js";
+import { detectLegacyVbriefLayout, detectXbriefConvergence } from "./detect.js";
+import { hasVbriefDeprecationMarker, isDirectory, isEffectivelyEmptyDir } from "./fs-helpers.js";
 import { renderXbriefMigrationLine, xbriefMigrationGuidance } from "./signpost.js";
 import { rewriteEmbeddedTokens, transformArtifactV06ToV08Transactional } from "./transforms.js";
 function collectFiles(root, acc = []) {
@@ -52,7 +52,7 @@ function backupLegacyTree(projectRoot, legacyDir) {
     cpSync(legacyDir, join(backupRoot, LEGACY_ARTIFACT_DIR), { recursive: true });
     return backupRoot;
 }
-function migrateLegacyTree(projectRoot, legacyDir) {
+function migrateLegacyTree(projectRoot, legacyDir, options) {
     const migratedDir = join(projectRoot, MIGRATED_ARTIFACT_DIR);
     if (existsSync(migratedDir)) {
         throw new Error(`refusing to migrate: '${MIGRATED_ARTIFACT_DIR}/' already exists alongside '${LEGACY_ARTIFACT_DIR}/'`);
@@ -71,7 +71,15 @@ function migrateLegacyTree(projectRoot, legacyDir) {
             writeMigratedFile(srcPath, destPath);
         }
         renameOrReplace(stagedDir, migratedDir);
-        rmSync(legacyDir, { recursive: true, force: true });
+        // Converge to a single unambiguous root: the fully-migrated legacy tree is
+        // either removed (default) or retained for read-compat behind an explicit
+        // deprecation marker so it never looks like an active source of truth (#2270).
+        if (options.keepLegacy) {
+            writeVbriefDeprecationMarker(legacyDir);
+        }
+        else {
+            rmSync(legacyDir, { recursive: true, force: true });
+        }
         return { backupDir, files: files.length };
     }
     catch (err) {
@@ -79,6 +87,36 @@ function migrateLegacyTree(projectRoot, legacyDir) {
         throw err;
     }
 }
+/** Idempotently write the legacy-root deprecation marker (#2270). */
+function writeVbriefDeprecationMarker(legacyDir) {
+    mkdirSync(legacyDir, { recursive: true });
+    if (hasVbriefDeprecationMarker(legacyDir)) {
+        return;
+    }
+    writeFileSync(join(legacyDir, VBRIEF_DEPRECATION_MARKER_FILENAME), VBRIEF_DEPRECATION_MARKER_BODY, "utf8");
+}
+/**
+ * Converge a leftover legacy `vbrief/` root to an unambiguous state (#2270).
+ * An effectively-empty tree is removed by default (single canonical root); a
+ * tree with real content — or an empty tree when `retain` is requested — is
+ * kept for read-compat behind an explicit deprecation marker. Idempotent: a
+ * missing dir or an already-marked dir is a no-op.
+ */
+export function convergeLegacyVbriefRoot(projectRoot, options) {
+    const legacyDir = join(projectRoot, LEGACY_ARTIFACT_DIR);
+    if (!isDirectory(legacyDir)) {
+        return "removed";
+    }
+    if (hasVbriefDeprecationMarker(legacyDir)) {
+        return "marker";
+    }
+    if (isEffectivelyEmptyDir(legacyDir) && !options.retain) {
+        rmSync(legacyDir, { recursive: true, force: true });
+        return "removed";
+    }
+    writeVbriefDeprecationMarker(legacyDir);
+    return "marker";
+}
 function renameOrReplace(src, dest) {
     if (existsSync(dest)) {
         rmSync(dest, { recursive: true, force: true });
@@ -107,9 +145,58 @@ function runAgentsRefresh(projectRoot, frameworkRoot, io) {
     io.writeOut(`AGENTS.md updated (state=${state}).\n`);
     return 0;
 }
-/** Core orchestrator for the consumer xbrief rename (#2110). */
+/** Core orchestrator for the consumer xbrief rename (#2110) + convergence (#2270). */
 export function runXbriefMigration(args, _io) {
     const projectRoot = resolve(args.projectRoot);
+    const legacyDir = join(projectRoot, LEGACY_ARTIFACT_DIR);
+    const keepLegacy = args.keepLegacy ?? false;
+    const convergence = detectXbriefConvergence(projectRoot);
+    switch (convergence.state) {
+        // Already converged: legacy root is retained behind an explicit marker.
+        // Rerun is a pure no-op (no re-removal, no duplicate marker) — idempotent.
+        case "xbrief-marker":
+            return {
+                kind: "converged",
+                action: "marker",
+                already: true,
+                message: `Legacy '${LEGACY_ARTIFACT_DIR}/' already carries a deprecation marker — layout already converged.`,
+            };
+        // Ambiguous dual-empty root: a fully-migrated empty legacy tree. Converge to
+        // a single canonical root by removing it (or marking it when read-compat
+        // retention is requested); never leave two indistinguishable empty roots.
+        // Read-compat retention is only honored when a canonical xbrief/ actually
+        // has content — marking an empty legacy root with no canonical replacement
+        // would strand the project behind a marker that claims a migration that
+        // never happened, so that case always removes the stray empty root.
+        case "empty-vbrief": {
+            const retain = keepLegacy && convergence.xbriefHasContent;
+            const action = convergeLegacyVbriefRoot(projectRoot, { retain });
+            let message;
+            if (action === "removed") {
+                message = convergence.xbriefHasContent
+                    ? `Converged layout: removed empty legacy '${LEGACY_ARTIFACT_DIR}/' — single '${MIGRATED_ARTIFACT_DIR}/' root.`
+                    : `Converged layout: removed empty legacy '${LEGACY_ARTIFACT_DIR}/' — no canonical '${MIGRATED_ARTIFACT_DIR}/' root to migrate to yet.`;
+            }
+            else {
+                message = `Converged layout: wrote deprecation marker to legacy '${LEGACY_ARTIFACT_DIR}/' (retained for read-compat).`;
+            }
+            return { kind: "converged", action, already: false, message };
+        }
+        // Legacy content coexisting with a populated canonical xbrief/. We never
+        // destructively merge; converge non-destructively by marking the legacy
+        // tree deprecated so it no longer looks like an active source of truth.
+        case "dual-populated": {
+            convergeLegacyVbriefRoot(projectRoot, { retain: true });
+            return {
+                kind: "converged",
+                action: "marker",
+                already: false,
+                message: `Converged layout: '${MIGRATED_ARTIFACT_DIR}/' is canonical; wrote deprecation marker to legacy '${LEGACY_ARTIFACT_DIR}/' (retained for read-compat).`,
+            };
+        }
+        default:
+            break;
+    }
     const detection = detectLegacyVbriefLayout(projectRoot);
     if (!detection.legacyLayout) {
         return {
@@ -117,7 +204,6 @@ export function runXbriefMigration(args, _io) {
             message: "Project is already on the xbrief layout — nothing to migrate.",
         };
     }
-    const legacyDir = join(projectRoot, LEGACY_ARTIFACT_DIR);
     if (!isDirectory(legacyDir)) {
         return {
             kind: "config",
@@ -134,7 +220,7 @@ export function runXbriefMigration(args, _io) {
         }
     }
     try {
-        const { backupDir, files } = migrateLegacyTree(projectRoot, legacyDir);
+        const { backupDir, files } = migrateLegacyTree(projectRoot, legacyDir, { keepLegacy });
         return { kind: "migrated", backupDir, files };
     }
     catch (err) {
@@ -165,6 +251,9 @@ export function emitXbriefMigration(outcome, io, options = {}) {
             io.writeOut(`Migrated ${outcome.files} file(s) from ${LEGACY_ARTIFACT_DIR}/ to ${MIGRATED_ARTIFACT_DIR}/.\n` +
                 `Backup written to ${outcome.backupDir}.\n`);
             return 0;
+        case "converged":
+            io.writeOut(`${outcome.message}\n`);
+            return 0;
         default: {
             const _exhaustive = outcome;
             return _exhaustive;

package/dist/xbrief-migrate/signpost.d.ts

@@ -1,5 +1,11 @@
 /** Operator guidance for the TS-native xbrief rename (#2034 / #2110). */
 export declare function xbriefMigrationGuidance(): string;
-/** One-line doctor / ritual signpost mirroring `renderPrecutoverLine` (#2110). */
+/**
+ * One-line doctor / ritual signpost mirroring `renderPrecutoverLine` (#2110),
+ * reporting an unambiguous convergence state (#2270). A migrated project reads
+ * as `xbrief active` plus either `vbrief legacy marker` or `vbrief removed`; a
+ * stray empty legacy root is called out as a pending convergence rather than a
+ * generic "run migrate" dead end — never a dual-empty-root ambiguity.
+ */
 export declare function renderXbriefMigrationLine(projectRoot: string): string;
 //# sourceMappingURL=signpost.d.ts.map

package/dist/xbrief-migrate/signpost.js

@@ -1,13 +1,28 @@
-import { detectLegacyVbriefLayout } from "./detect.js";
+import { detectLegacyVbriefLayout, detectXbriefConvergence } from "./detect.js";
 /** Operator guidance for the TS-native xbrief rename (#2034 / #2110). */
 export function xbriefMigrationGuidance() {
     return "Run `deft migrate:xbrief` (or `task migrate:xbrief`) to convert vbrief/ to xbrief/ safely.";
 }
-/** One-line doctor / ritual signpost mirroring `renderPrecutoverLine` (#2110). */
+/**
+ * One-line doctor / ritual signpost mirroring `renderPrecutoverLine` (#2110),
+ * reporting an unambiguous convergence state (#2270). A migrated project reads
+ * as `xbrief active` plus either `vbrief legacy marker` or `vbrief removed`; a
+ * stray empty legacy root is called out as a pending convergence rather than a
+ * generic "run migrate" dead end — never a dual-empty-root ambiguity.
+ */
 export function renderXbriefMigrationLine(projectRoot) {
+    const convergence = detectXbriefConvergence(projectRoot);
+    // Converged: legacy vbrief/ retained for read-compat behind an explicit marker.
+    if (convergence.state === "xbrief-marker") {
+        return "xBrief migration: converged -- xbrief active, vbrief legacy marker (read-compat).";
+    }
+    // Ambiguous dual-empty root: canonical xbrief/ (or none) plus a stray empty vbrief/.
+    if (convergence.state === "empty-vbrief") {
+        return `xBrief migration: converge pending -- xbrief active, empty legacy vbrief/ present. ${xbriefMigrationGuidance()}`;
+    }
     const { legacyLayout, reasons } = detectLegacyVbriefLayout(projectRoot);
     if (!legacyLayout) {
-        return "xBrief migration: none -- project is on the xbrief layout.";
+        return "xBrief migration: none -- xbrief active, vbrief removed.";
     }
     const maxReasons = 3;
     const shown = reasons.slice(0, maxReasons);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.68.1",
+  "version": "0.70.0",
   "description": "TypeScript engine core for the Directive framework.",
   "type": "module",
   "main": "./dist/index.js",
@@ -90,6 +90,10 @@
       "types": "./dist/release-e2e/index.d.ts",
       "default": "./dist/release-e2e/index.js"
     },
+    "./resolution": {
+      "types": "./dist/resolution/index.d.ts",
+      "default": "./dist/resolution/index.js"
+    },
     "./pr-merge-readiness": {
       "types": "./dist/pr-merge-readiness/index.d.ts",
       "default": "./dist/pr-merge-readiness/index.js"
@@ -245,8 +249,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-content": "^0.68.1",
-    "@deftai/directive-types": "^0.68.1",
+    "@deftai/directive-content": "^0.70.0",
+    "@deftai/directive-types": "^0.70.0",
     "archiver": "^8.0.0"
   },
   "scripts": {