@deftai/directive-core 0.60.0 → 0.61.1

package/dist/spec-authority/narratives.js

@@ -0,0 +1,84 @@
+import { readFileSync } from "node:fs";
+import { SPECIFICATION_NARRATIVE_KEY_ORDER } from "../render/constants.js";
+import { STAKEHOLDER_EXCLUDED_NARRATIVE_KEYS } from "./constants.js";
+function loadJson(path) {
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+function planNarratives(doc) {
+    const plan = doc.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan))
+        return {};
+    const narratives = plan.narratives;
+    if (typeof narratives !== "object" || narratives === null || Array.isArray(narratives))
+        return {};
+    const out = {};
+    for (const [key, val] of Object.entries(narratives)) {
+        if (typeof val === "string")
+            out[key] = val;
+    }
+    return out;
+}
+function isExcludedNarrativeKey(key) {
+    return STAKEHOLDER_EXCLUDED_NARRATIVE_KEYS.has(key.toLowerCase().replace(/\s+/g, ""));
+}
+/** Merge product narratives per Wave 0 locked precedence. */
+export function resolveExportNarratives(authority) {
+    const pd = loadJson(authority.projectDefPath);
+    const pdNarratives = planNarratives(pd);
+    if (authority.kind === "greenfield") {
+        const filtered = {};
+        for (const [key, val] of Object.entries(pdNarratives)) {
+            if (!isExcludedNarrativeKey(key) && val.trim())
+                filtered[key] = val;
+        }
+        return filtered;
+    }
+    const specPath = authority.specPath;
+    if (!specPath)
+        return pdNarratives;
+    const spec = loadJson(specPath);
+    const specNarratives = planNarratives(spec);
+    const merged = {};
+    for (const [key, val] of Object.entries(specNarratives)) {
+        if (!isExcludedNarrativeKey(key) && val.trim())
+            merged[key] = val;
+    }
+    // PD identity additive when missing from spec.
+    const identityHints = ["overview", "architecture", "risksandunknowns", "risks", "unknowns"];
+    for (const [key, val] of Object.entries(pdNarratives)) {
+        if (!val.trim() || isExcludedNarrativeKey(key))
+            continue;
+        const lower = key.toLowerCase().replace(/\s+/g, "");
+        const isIdentity = identityHints.some((h) => lower.includes(h)) || lower === "overview";
+        if (!isIdentity)
+            continue;
+        const specHasKey = Object.keys(merged).some((k) => k.toLowerCase() === lower);
+        if (!specHasKey)
+            merged[key] = val;
+    }
+    return merged;
+}
+export function renderNarrativeSections(narratives) {
+    const lines = [];
+    const rendered = new Set();
+    for (const key of SPECIFICATION_NARRATIVE_KEY_ORDER) {
+        const val = narratives[key];
+        if (val?.trim()) {
+            lines.push(`## ${key}\n`, `${val}\n`);
+            rendered.add(key);
+        }
+    }
+    for (const key of Object.keys(narratives).sort()) {
+        if (rendered.has(key) || !narratives[key]?.trim())
+            continue;
+        lines.push(`## ${key}\n`, `${narratives[key]}\n`);
+    }
+    return lines;
+}
+export function greenfieldOverviewNonEmpty(authority) {
+    const pd = loadJson(authority.projectDefPath);
+    const narratives = planNarratives(pd);
+    const overview = Object.entries(narratives).find(([k]) => k.toLowerCase() === "overview");
+    return overview !== undefined && overview[1].trim().length > 0;
+}
+//# sourceMappingURL=narratives.js.map

package/dist/spec-authority/resolver.d.ts

@@ -0,0 +1,15 @@
+export type SpecAuthorityKind = "full-spec" | "greenfield";
+export interface ResolvedSpecAuthority {
+    readonly kind: SpecAuthorityKind;
+    readonly projectRoot: string;
+    readonly vbriefDir: string;
+    readonly projectDefPath: string;
+    readonly specPath: string | null;
+    readonly banner: string;
+}
+export declare function resolveSpecAuthority(projectRoot: string): ResolvedSpecAuthority | null;
+export declare function readSpecMarkdown(projectRoot: string): string;
+export declare function isFullSpecState(projectRoot: string): boolean;
+export declare function isGreenfieldSpecExport(projectRoot: string): boolean;
+export declare function isCurrentGeneratedSpecification(projectRoot: string): boolean;
+//# sourceMappingURL=resolver.d.ts.map

package/dist/spec-authority/resolver.js

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { SPEC_RENDER_BANNER } from "../render/constants.js";
+import { EXPORT_SPEC_PD_BANNER, GENERATED_SPEC_PURPOSE, GENERATED_SPEC_SOURCE_PD, GENERATED_SPEC_SOURCE_SPEC, } from "./constants.js";
+const SPEC_REL = join("vbrief", "specification.vbrief.json");
+const PD_REL = join("vbrief", "PROJECT-DEFINITION.vbrief.json");
+export function resolveSpecAuthority(projectRoot) {
+    const root = projectRoot;
+    const vbriefDir = join(root, "vbrief");
+    const projectDefPath = join(root, PD_REL);
+    if (!existsSync(projectDefPath))
+        return null;
+    const specPath = join(root, SPEC_REL);
+    const hasSpec = existsSync(specPath);
+    const kind = hasSpec ? "full-spec" : "greenfield";
+    const banner = kind === "full-spec" ? SPEC_RENDER_BANNER : EXPORT_SPEC_PD_BANNER;
+    return {
+        kind,
+        projectRoot: root,
+        vbriefDir,
+        projectDefPath,
+        specPath: hasSpec ? specPath : null,
+        banner,
+    };
+}
+export function readSpecMarkdown(projectRoot) {
+    const path = join(projectRoot, "SPECIFICATION.md");
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+export function isFullSpecState(projectRoot) {
+    const authority = resolveSpecAuthority(projectRoot);
+    if (authority?.kind !== "full-spec")
+        return false;
+    const specMd = readSpecMarkdown(projectRoot);
+    return specMd.includes(GENERATED_SPEC_PURPOSE) && specMd.includes(GENERATED_SPEC_SOURCE_SPEC);
+}
+export function isGreenfieldSpecExport(projectRoot) {
+    const authority = resolveSpecAuthority(projectRoot);
+    if (authority?.kind !== "greenfield")
+        return false;
+    const specMd = readSpecMarkdown(projectRoot);
+    return specMd.includes(GENERATED_SPEC_PURPOSE) && specMd.includes(GENERATED_SPEC_SOURCE_PD);
+}
+export function isCurrentGeneratedSpecification(projectRoot) {
+    return isFullSpecState(projectRoot) || isGreenfieldSpecExport(projectRoot);
+}
+//# sourceMappingURL=resolver.js.map

package/dist/validate-content/validate-strategy-output.js

@@ -1,17 +1,9 @@
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readdirSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { checkSpecMigrationFidelity } from "../spec-authority/migration-fidelity.js";
+import { isFullSpecState } from "../spec-authority/resolver.js";
 import { isDatePrefixedVbriefFilename } from "./filename.js";
-const GENERATED_SPEC_PURPOSE = "<!-- Purpose: rendered specification -->";
-const GENERATED_SPEC_SOURCE = "<!-- Source of truth: vbrief/specification.vbrief.json -->";
 const LIFECYCLE_DIRS = ["proposed", "pending", "active", "completed", "cancelled"];
-function readTextSafe(path) {
-    try {
-        return readFileSync(path, "utf8");
-    }
-    catch {
-        return "";
-    }
-}
 function isDirSafe(path) {
     try {
         return statSync(path).isDirectory();
@@ -30,20 +22,6 @@ function isDeftFrameworkRoot(projectRoot) {
         (isDirSafe(join(projectRoot, "content", "strategies")) ||
             isDirSafe(join(projectRoot, "strategies"))));
 }
-function hasCompleteLifecycle(vbriefDir) {
-    return LIFECYCLE_DIRS.every((folder) => {
-        const p = join(vbriefDir, folder);
-        return existsSync(p) && statSync(p).isDirectory();
-    });
-}
-function isPostCutoverFullSpecState(projectRoot) {
-    const vbriefDir = join(projectRoot, "vbrief");
-    const specMd = readTextSafe(join(projectRoot, "SPECIFICATION.md"));
-    return (existsSync(join(vbriefDir, "PROJECT-DEFINITION.vbrief.json")) &&
-        hasCompleteLifecycle(vbriefDir) &&
-        specMd.includes(GENERATED_SPEC_PURPOSE) &&
-        specMd.includes(GENERATED_SPEC_SOURCE));
-}
 /** Pure validator returning error strings (empty == pass). */
 export function validateStrategyOutput(projectRoot, strict = false) {
     const root = resolve(projectRoot);
@@ -63,7 +41,7 @@ export function validateStrategyOutput(projectRoot, strict = false) {
             "(see v0-20-contract.md and task project:render).");
     }
     const specLegacy = join(vbriefDir, "specification.vbrief.json");
-    if (existsSync(specLegacy) && !isDeftFrameworkRoot(root) && !isPostCutoverFullSpecState(root)) {
+    if (existsSync(specLegacy) && !isDeftFrameworkRoot(root) && !isFullSpecState(root)) {
         errors.push("Legacy artifact vbrief/specification.vbrief.json present. " +
             "v0.20 strategies MUST NOT dual-write the old specification.vbrief.json " +
             "alongside scope vBRIEFs in the lifecycle folders. " +
@@ -85,6 +63,7 @@ export function validateStrategyOutput(projectRoot, strict = false) {
             }
         }
     }
+    errors.push(...checkSpecMigrationFidelity(root));
     return errors;
 }
 const FAILURE_HEADER = "❌ Strategy output shape validation FAILED (v0.20 contract gate)";

package/dist/vbrief-validate/main.js

@@ -122,6 +122,11 @@ export function cmdVbriefValidate(argv) {
     if (argv[0] === "conformance") {
         return runConformance(argv.slice(1));
     }
+    if (argv.includes("--staged") ||
+        (argv.includes("--all") &&
+            !argv.some((a) => a === "--vbrief-dir" || a.startsWith("--vbrief-dir=")))) {
+        return runConformance(argv);
+    }
     return runValidate(argv);
 }
 //# sourceMappingURL=main.js.map

package/dist/vbrief-validate/precutover.d.ts

@@ -1,35 +1,21 @@
+import { isFullSpecState, isGreenfieldSpecExport } from "../spec-authority/resolver.js";
 import { DEPRECATION_SENTINEL } from "../vbrief-build/constants.js";
 export { DEPRECATION_SENTINEL as DEPRECATED_REDIRECT_SENTINEL };
 export declare function missingLifecycleFolders(projectRoot: string): string[];
 /** Return true when markdown content is a migration redirect stub. */
 export declare function isDeprecationRedirect(content: string): boolean;
+/** Full-spec generated export (specification.vbrief.json source line). */
 export declare function isGeneratedSpecificationExport(projectRoot: string, content: string): boolean;
-/** Return true for a fully current ``task spec:render`` root export. */
+/** Return true for a fully current generated spec export (full-spec or greenfield). */
 export declare function isCurrentGeneratedSpecification(projectRoot: string, content: string): boolean;
 /** Return root artifact filenames that are legacy pre-v0.20 inputs (#793 / migrate preflight). */
 export declare function detectPreCutoverLegacy(projectRoot: string): string[];
 /** Structured result of a pre-cutover (pre-v0.20 document model) probe. */
 export interface PrecutoverDetection {
-    /** True when any legacy pre-v0.20 artifact still needs migration. */
     preCutover: boolean;
-    /** Human-readable reasons; empty when the project is on the current model. */
     reasons: string[];
 }
-/**
- * Detect whether ``projectRoot`` still carries pre-v0.20 (pre-cutover) document-model
- * artifacts that need migration. Mirrors the AGENTS.md "Pre-Cutover Check" rule and the
- * legacy ``scripts/_precutover.py`` helper: a project is pre-cutover when any of the
- * following hold:
- *
- * - ``SPECIFICATION.md`` exists and is neither a deprecation redirect nor a current
- *   generated spec export;
- * - ``PROJECT.md`` exists and is not a deprecation redirect;
- * - ``vbrief/`` exists but is missing one or more lifecycle folders.
- */
 export declare function detectPreCutover(projectRoot: string): PrecutoverDetection;
-/**
- * Render the single-line pre-cutover status string surfaced by ``deft doctor``.
- * Flags the migration-needed state with reasons, or reports a clean current-model state.
- */
 export declare function renderPrecutoverLine(projectRoot: string): string;
+export { isFullSpecState, isGreenfieldSpecExport };
 //# sourceMappingURL=precutover.d.ts.map

package/dist/vbrief-validate/precutover.js

@@ -1,10 +1,10 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
+import { GENERATED_SPEC_PURPOSE, GENERATED_SPEC_SOURCE_SPEC } from "../spec-authority/constants.js";
+import { isFullSpecState, isGreenfieldSpecExport } from "../spec-authority/resolver.js";
 import { DEPRECATION_SENTINEL } from "../vbrief-build/constants.js";
 export { DEPRECATION_SENTINEL as DEPRECATED_REDIRECT_SENTINEL };
 const DEPRECATION_REDIRECT_PURPOSE = "<!-- Purpose: deprecation redirect -->";
-const GENERATED_SPEC_PURPOSE = "<!-- Purpose: rendered specification -->";
-const GENERATED_SPEC_SOURCE = "<!-- Source of truth: vbrief/specification.vbrief.json -->";
 const SPEC_SOURCE_RELPATH = join("vbrief", "specification.vbrief.json");
 const LIFECYCLE_FOLDERS = ["proposed", "pending", "active", "completed", "cancelled"];
 export function missingLifecycleFolders(projectRoot) {
@@ -18,14 +18,19 @@ function hasCompleteLifecycle(projectRoot) {
 export function isDeprecationRedirect(content) {
     return content.includes(DEPRECATION_SENTINEL) || content.includes(DEPRECATION_REDIRECT_PURPOSE);
 }
+/** Full-spec generated export (specification.vbrief.json source line). */
 export function isGeneratedSpecificationExport(projectRoot, content) {
     return (content.includes(GENERATED_SPEC_PURPOSE) &&
-        content.includes(GENERATED_SPEC_SOURCE) &&
+        content.includes(GENERATED_SPEC_SOURCE_SPEC) &&
         existsSync(join(projectRoot, SPEC_SOURCE_RELPATH)));
 }
-/** Return true for a fully current ``task spec:render`` root export. */
+/** Return true for a fully current generated spec export (full-spec or greenfield). */
 export function isCurrentGeneratedSpecification(projectRoot, content) {
-    return isGeneratedSpecificationExport(projectRoot, content) && hasCompleteLifecycle(projectRoot);
+    if (!hasCompleteLifecycle(projectRoot))
+        return false;
+    if (isGeneratedSpecificationExport(projectRoot, content))
+        return true;
+    return isGreenfieldSpecExport(projectRoot);
 }
 function isFile(path) {
     try {
@@ -46,8 +51,11 @@ function safeReadText(path) {
 function rootMarkdownIsLegacy(projectRoot, filename, content) {
     if (isDeprecationRedirect(content))
         return false;
-    if (filename === "SPECIFICATION.md" && isGeneratedSpecificationExport(projectRoot, content)) {
-        return false;
+    if (filename === "SPECIFICATION.md") {
+        if (isGeneratedSpecificationExport(projectRoot, content))
+            return false;
+        if (isGreenfieldSpecExport(projectRoot))
+            return false;
     }
     return filename === "SPECIFICATION.md" || filename === "PROJECT.md";
 }
@@ -65,17 +73,6 @@ export function detectPreCutoverLegacy(projectRoot) {
     }
     return legacy;
 }
-/**
- * Detect whether ``projectRoot`` still carries pre-v0.20 (pre-cutover) document-model
- * artifacts that need migration. Mirrors the AGENTS.md "Pre-Cutover Check" rule and the
- * legacy ``scripts/_precutover.py`` helper: a project is pre-cutover when any of the
- * following hold:
- *
- * - ``SPECIFICATION.md`` exists and is neither a deprecation redirect nor a current
- *   generated spec export;
- * - ``PROJECT.md`` exists and is not a deprecation redirect;
- * - ``vbrief/`` exists but is missing one or more lifecycle folders.
- */
 export function detectPreCutover(projectRoot) {
     const reasons = [];
     const specPath = join(projectRoot, "SPECIFICATION.md");
@@ -101,17 +98,14 @@ export function detectPreCutover(projectRoot) {
     }
     return { preCutover: reasons.length > 0, reasons };
 }
-/**
- * Render the single-line pre-cutover status string surfaced by ``deft doctor``.
- * Flags the migration-needed state with reasons, or reports a clean current-model state.
- */
 export function renderPrecutoverLine(projectRoot) {
     const { preCutover, reasons } = detectPreCutover(projectRoot);
     if (!preCutover) {
         return "Pre-cutover: none -- project is on the current vBRIEF document model.";
     }
-    // Collapse any embedded newlines so the status line stays a single line (CWE-116).
     const summary = reasons.join("; ").replace(/\r?\n/g, " ");
     return `Pre-cutover: migration needed -- ${summary}. Run \`deft migrate:vbrief\` to migrate.`;
 }
+// Re-export for classify callers (#2013).
+export { isFullSpecState, isGreenfieldSpecExport };
 //# sourceMappingURL=precutover.js.map

package/dist/verify-env/verify-hooks-installed.d.ts

@@ -5,9 +5,9 @@ export interface EvaluateResult {
     readonly stream: OutputStream;
 }
 export declare const REQUIRED_HOOKS: readonly ["pre-commit", "pre-push"];
-export declare const SCRIPTS_PROBE = "preflight_branch.py";
-export declare const GATE_SCRIPTS: readonly ["preflight_branch.py", "verify_encoding.py", "preflight_gh.py"];
-export declare const SCRIPTS_DIR_CANDIDATES: readonly ["scripts", ".deft/core/scripts", "deft/scripts"];
+/** Substrings each hook must contain when it dispatches through the deft CLI (#2049). */
+export declare const PRE_COMMIT_DEFT_COMMANDS: readonly ["verify:branch", "verify:encoding"];
+export declare const PRE_PUSH_DEFT_COMMANDS: readonly ["preflight-gh"];
 export type GitConfigReader = (projectRoot: string) => {
     hooksPath: string | null;
     error: string | null;

package/dist/verify-env/verify-hooks-installed.js

@@ -1,14 +1,18 @@
 import * as childProcess from "node:child_process";
-import { accessSync, constants, statSync } from "node:fs";
+import { accessSync, constants, readFileSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
 export const REQUIRED_HOOKS = ["pre-commit", "pre-push"];
-export const SCRIPTS_PROBE = "preflight_branch.py";
-export const GATE_SCRIPTS = [
-    "preflight_branch.py",
-    "verify_encoding.py",
-    "preflight_gh.py",
+/** Substrings each hook must contain when it dispatches through the deft CLI (#2049). */
+export const PRE_COMMIT_DEFT_COMMANDS = ["verify:branch", "verify:encoding"];
+export const PRE_PUSH_DEFT_COMMANDS = ["preflight-gh"];
+/** Patterns that indicate legacy Python-dispatched hooks (pre-#2049). */
+const LEGACY_HOOK_PATTERNS = [
+    /\.py\b/i,
+    /\bpython\b/i,
+    /\bdeft_py\b/,
+    /\bSCRIPTS_DIR\b/,
+    /\bpreflight_branch\.py\b/,
 ];
-export const SCRIPTS_DIR_CANDIDATES = ["scripts", ".deft/core/scripts", "deft/scripts"];
 function defaultGitConfigReader(projectRoot) {
     try {
         const stdout = childProcess.execFileSync("git", ["-C", projectRoot, "config", "--get", "core.hooksPath"], {
@@ -45,15 +49,6 @@ function isDirectory(path) {
         return false;
     }
 }
-function resolveScriptsDir(projectRoot) {
-    for (const rel of SCRIPTS_DIR_CANDIDATES) {
-        const candidate = join(projectRoot, rel);
-        if (isFile(join(candidate, SCRIPTS_PROBE))) {
-            return candidate;
-        }
-    }
-    return null;
-}
 function isPosix(platform) {
     return platform !== "win32";
 }
@@ -66,6 +61,36 @@ function hookExecutable(hookPath) {
         return false;
     }
 }
+function readHookContent(hookPath) {
+    try {
+        return readFileSync(hookPath, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function usesLegacyPythonDispatch(content) {
+    return LEGACY_HOOK_PATTERNS.some((pattern) => pattern.test(content));
+}
+function hookInvokesDeftCli(content, requiredCommands) {
+    if (!/\bdeft\b/.test(content))
+        return false;
+    if (usesLegacyPythonDispatch(content))
+        return false;
+    return requiredCommands.every((cmd) => content.includes(cmd));
+}
+function validateHookContent(hookName, content, requiredCommands) {
+    if (content === null) {
+        return `${hookName}: unreadable hook file`;
+    }
+    if (usesLegacyPythonDispatch(content)) {
+        return `${hookName}: still dispatches through Python scripts (expected deft CLI only, #2049)`;
+    }
+    if (!hookInvokesDeftCli(content, requiredCommands)) {
+        return `${hookName}: missing required deft CLI gate(s): ${requiredCommands.join(", ")}`;
+    }
+    return null;
+}
 /** Pure evaluator mirroring scripts/verify_hooks_installed.py::evaluate. */
 export function evaluate(projectRoot, options = {}) {
     const root = resolve(projectRoot);
@@ -132,30 +157,37 @@ export function evaluate(projectRoot, options = {}) {
             };
         }
     }
-    const scriptsDir = resolveScriptsDir(root);
-    if (scriptsDir === null) {
+    const preCommitIssue = validateHookContent("pre-commit", readHookContent(join(hooksDir, "pre-commit")), PRE_COMMIT_DEFT_COMMANDS);
+    if (preCommitIssue) {
+        return {
+            code: 1,
+            message: `❌ deft hooks wired but NON-FUNCTIONAL: ${preCommitIssue} (#2049).\n` +
+                "  Recovery: re-run the deft installer / `task setup` to refresh .githooks/.",
+            stream: "stderr",
+        };
+    }
+    const prePushContent = readHookContent(join(hooksDir, "pre-push"));
+    const prePushIssue = validateHookContent("pre-push", prePushContent, PRE_PUSH_DEFT_COMMANDS);
+    if (prePushIssue) {
         return {
             code: 1,
-            message: "❌ deft hooks wired but NON-FUNCTIONAL: the gate scripts cannot be resolved.\n" +
-                `  Looked for ${SCRIPTS_PROBE} under: ${SCRIPTS_DIR_CANDIDATES.join(", ")} (relative to ${root}).\n` +
-                "  Recovery: re-run the deft installer so the payload is present.",
+            message: `❌ deft hooks wired but NON-FUNCTIONAL: ${prePushIssue} (#2049).\n` +
+                "  Recovery: re-run the deft installer / `task setup` to refresh .githooks/.",
             stream: "stderr",
         };
     }
-    const missingScripts = GATE_SCRIPTS.filter((s) => !isFile(join(scriptsDir, s)));
-    if (missingScripts.length > 0) {
+    if (prePushContent?.includes("verify:branch")) {
         return {
             code: 1,
-            message: `❌ deft hooks wired but NON-FUNCTIONAL: ${scriptsDir} is missing ` +
-                `gate script(s): ${missingScripts.join(", ")} (#1463 false-green).\n` +
-                "  Recovery: re-run the deft installer to restore the payload.",
+            message: "❌ deft hooks wired but NON-FUNCTIONAL: pre-push must not invoke verify:branch (#1814).\n" +
+                "  Recovery: re-run the deft installer / `task setup` to refresh .githooks/.",
             stream: "stderr",
         };
     }
     return {
         code: 0,
         message: `✓ deft hooks installed and functional: core.hooksPath=${hooksPath}, ` +
-            `hooks ${REQUIRED_HOOKS.join(", ")} present, gate scripts resolve under ${scriptsDir}.`,
+            `hooks ${REQUIRED_HOOKS.join(", ")} present and dispatch via deft CLI (#2049).`,
         stream: "stdout",
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.60.0",
+  "version": "0.61.1",
   "description": "TypeScript engine core for the Directive framework.",
   "type": "module",
   "main": "./dist/index.js",
@@ -221,8 +221,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-content": "^0.60.0",
-    "@deftai/directive-types": "^0.60.0"
+    "@deftai/directive-content": "^0.61.1",
+    "@deftai/directive-types": "^0.61.1"
   },
   "scripts": {
     "build": "tsc -b",