@deftai/directive-core 0.86.0 → 0.87.0

package/dist/triage/queue/show.js

@@ -0,0 +1,293 @@
+/**
+ * triage:show default + operator brief renderers (#1128 / #2890).
+ *
+ * Default format mirrors the pre-Python-removal `render_show` surface.
+ * `--format=operator` emits a pasteable Phase 3 candidate brief backbone;
+ * the agent still owns lean (not invented here).
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { CACHE_DIR_NAME, CACHE_SOURCE_GITHUB_ISSUE } from "./constants.js";
+function parseLabels(raw) {
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    const labels = [];
+    for (const item of raw) {
+        if (typeof item === "object" && item !== null) {
+            const name = item.name;
+            if (typeof name === "string") {
+                labels.push(name);
+            }
+        }
+        else if (typeof item === "string") {
+            labels.push(item);
+        }
+    }
+    return labels;
+}
+/** Collapse CR/LF so cached attacker text cannot break markdown bullets (P2). */
+export function oneLine(value) {
+    return value.replace(/\r?\n/gu, " ").trim();
+}
+/**
+ * Resolve a safe issue link. Always construct the canonical github.com path for
+ * `owner/name#N` rather than trusting payload URL substrings (CodeQL
+ * incomplete-url-substring-sanitization).
+ */
+export function resolveIssueHtmlUrl(repo, number) {
+    return `https://github.com/${repo}/issues/${number}`;
+}
+/** Load a single cached issue (include closed) or null on miss. */
+export function loadCachedIssueDetail(repo, number, options = {
+    projectRoot: process.cwd(),
+}) {
+    if (!repo.includes("/")) {
+        throw new Error(`repo must be 'owner/name'; got '${repo}'`);
+    }
+    const parts = repo.split("/", 2);
+    const owner = parts[0];
+    const name = parts[1];
+    if (owner === undefined || name === undefined || owner.length === 0 || name.length === 0) {
+        throw new Error(`repo must be 'owner/name'; got '${repo}'`);
+    }
+    const source = options.source ?? CACHE_SOURCE_GITHUB_ISSUE;
+    const cacheBase = options.cacheRoot !== null && options.cacheRoot !== undefined && options.cacheRoot.length > 0
+        ? resolve(options.cacheRoot)
+        : join(resolve(options.projectRoot), CACHE_DIR_NAME);
+    const entryDir = join(cacheBase, source, owner, name, String(number));
+    const rawPath = join(entryDir, "raw.json");
+    if (!existsSync(rawPath)) {
+        return null;
+    }
+    let payload;
+    try {
+        const parsed = JSON.parse(readFileSync(rawPath, { encoding: "utf8" }));
+        if (typeof parsed !== "object" || parsed === null) {
+            return null;
+        }
+        payload = parsed;
+    }
+    catch {
+        return null;
+    }
+    const n = typeof payload.number === "number" ? payload.number : number;
+    const stateRaw = payload.state ?? "open";
+    const state = typeof stateRaw === "string" ? stateRaw.toLowerCase() : "open";
+    const title = typeof payload.title === "string" ? payload.title : "";
+    const body = typeof payload.body === "string" ? payload.body : "";
+    const updatedAt = typeof payload.updated_at === "string"
+        ? payload.updated_at
+        : typeof payload.updatedAt === "string"
+            ? payload.updatedAt
+            : "";
+    return {
+        number: n,
+        title,
+        state,
+        labels: parseLabels(payload.labels),
+        updatedAt,
+        body,
+        htmlUrl: resolveIssueHtmlUrl(repo, n),
+    };
+}
+/** Default triage:show text (audit/cache oriented). */
+export function renderShow(options) {
+    const lines = [];
+    lines.push(`triage:show -- ${options.repo}#${options.number}`);
+    if (options.issue === null) {
+        lines.push("");
+        lines.push("  (issue not present in local cache)");
+        lines.push("  Run `task triage:bootstrap` to populate, or check the repo slug.");
+        return lines.join("\n");
+    }
+    const labels = options.issue.labels.map(oneLine);
+    lines.push(`  title:      ${oneLine(options.issue.title)}`);
+    lines.push(`  state:      ${oneLine(options.issue.state)}`);
+    lines.push(`  labels:     ${labels.length > 0 ? labels.join(", ") : "<none>"}`);
+    lines.push(`  updated_at: ${oneLine(options.issue.updatedAt)}`);
+    lines.push("");
+    lines.push(`  active xBRIEF reference: ${options.inActiveXbrief ? "yes" : "no"}`);
+    if (options.latestDecision !== null) {
+        const d = options.latestDecision;
+        lines.push(`  latest decision: ${oneLine(String(d.decision ?? "?"))} at ${oneLine(String(d.timestamp ?? "?"))} by ${oneLine(String(d.actor ?? "?"))}`);
+        if (typeof d.reason === "string" && d.reason.length > 0) {
+            lines.push(`    reason: ${oneLine(d.reason)}`);
+        }
+    }
+    else {
+        lines.push("  latest decision: <none -- untriaged>");
+    }
+    if (options.history.length > 0) {
+        lines.push("");
+        lines.push(`  history (${options.history.length} entries, oldest first):`);
+        for (const entry of options.history) {
+            const decision = oneLine(String(entry.decision ?? "?")).padEnd(14);
+            lines.push(`    - ${oneLine(String(entry.timestamp ?? "?"))} ${decision} by ${oneLine(String(entry.actor ?? "?"))}`);
+        }
+    }
+    return lines.join("\n");
+}
+/** Collapse blank lines and trim for summary extraction. */
+function normalizeBody(body) {
+    return body.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+}
+/**
+ * Extract a short problem/context summary (2–5 lines) from issue body.
+ * Prefers text before the first `##` section; falls back to leading paragraphs.
+ */
+export function extractBodySummary(body, maxLines = 5) {
+    const text = normalizeBody(body);
+    if (text.length === 0) {
+        return "(thin body / no summary)";
+    }
+    // Drop leading H1/title lines
+    let rest = text.replace(/^#[^\n]*\n+/u, "");
+    // Prefer content before first ## heading (often Summary/Description)
+    const firstSection = rest.search(/^##\s+/mu);
+    if (firstSection > 0) {
+        rest = rest.slice(0, firstSection).trim();
+    }
+    else if (firstSection === 0) {
+        // Body starts with ## — take the first section body
+        const next = rest.search(/\n##\s+/u);
+        const block = next === -1 ? rest : rest.slice(0, next);
+        rest = block.replace(/^##[^\n]*\n?/u, "").trim();
+    }
+    const paragraphs = rest
+        .split(/\n{2,}/u)
+        .map((p) => p.replace(/\s+/gu, " ").trim())
+        .filter((p) => p.length > 0 && !p.startsWith("#"));
+    if (paragraphs.length === 0) {
+        const lines = rest
+            .split("\n")
+            .map((l) => l.trim())
+            .filter((l) => l.length > 0 && !l.startsWith("#"));
+        if (lines.length === 0) {
+            return "(thin body / no summary)";
+        }
+        return lines.slice(0, maxLines).join("\n");
+    }
+    const out = [];
+    for (const para of paragraphs) {
+        if (out.length >= maxLines)
+            break;
+        // Soft-wrap long paragraphs into ~100-char lines for pasteability
+        if (para.length <= 120) {
+            out.push(para);
+        }
+        else {
+            const words = para.split(/\s+/u);
+            let line = "";
+            for (const w of words) {
+                const next = line.length === 0 ? w : `${line} ${w}`;
+                if (next.length > 100 && line.length > 0) {
+                    out.push(line);
+                    line = w;
+                    if (out.length >= maxLines)
+                        break;
+                }
+                else {
+                    line = next;
+                }
+            }
+            if (line.length > 0 && out.length < maxLines) {
+                out.push(line);
+            }
+        }
+    }
+    return out.slice(0, maxLines).join("\n");
+}
+/**
+ * Extract acceptance-criteria bullets from body, or a thin-body note.
+ * Looks for AC / Acceptance headings and checkbox / bullet lists under them.
+ */
+export function extractAcceptanceCriteria(body) {
+    const text = normalizeBody(body);
+    if (text.length === 0) {
+        return [];
+    }
+    const headingRe = /^#{1,3}\s*(?:acceptance\s*criteria|acceptance|ac\b|success\s*criteria)[^\n]*$/imu;
+    const match = headingRe.exec(text);
+    if (match === null || match.index === undefined) {
+        // Loose: checkbox list near top without a heading
+        const loose = [];
+        for (const line of text.split("\n")) {
+            const m = /^\s*[-*]\s*\[[ xX]\]\s+(.+)$/u.exec(line);
+            if (m?.[1] !== undefined) {
+                loose.push(m[1].trim());
+            }
+        }
+        return loose.slice(0, 12);
+    }
+    const after = text.slice(match.index + match[0].length);
+    // Stop only at a next ## (H2) peer section — keep ### subsections (A/B/C…) inside AC.
+    const nextPeer = after.search(/\n##\s+\S/u);
+    const section = nextPeer === -1 ? after : after.slice(0, nextPeer);
+    const bullets = [];
+    for (const line of section.split("\n")) {
+        const checkbox = /^\s*[-*]\s*\[[ xX]\]\s+(.+)$/u.exec(line);
+        if (checkbox?.[1] !== undefined) {
+            bullets.push(checkbox[1].trim());
+            continue;
+        }
+        // Prefer checkboxes under AC; plain bullets are also accepted
+        const bullet = /^\s*[-*]\s+(.+)$/u.exec(line);
+        if (bullet?.[1] !== undefined) {
+            // Skip nested subsection-only markers that are just headings-as-bullets
+            bullets.push(bullet[1].trim());
+            continue;
+        }
+        const numbered = /^\s*\d+[.)]\s+(.+)$/u.exec(line);
+        if (numbered?.[1] !== undefined) {
+            bullets.push(numbered[1].trim());
+        }
+    }
+    return bullets.slice(0, 12);
+}
+/** Operator-facing pasteable brief backbone for Phase 3 decisions (#2890). */
+export function renderOperatorBrief(options) {
+    const lines = [];
+    lines.push(`triage:show --format=operator -- ${options.repo}#${options.number}`);
+    if (options.issue === null) {
+        lines.push("");
+        lines.push("  (issue not present in local cache)");
+        lines.push("  Run `task triage:bootstrap` / re-sync per Phase 0, or check the repo slug.");
+        return lines.join("\n");
+    }
+    const issue = options.issue;
+    const link = issue.htmlUrl ?? resolveIssueHtmlUrl(options.repo, options.number);
+    const labels = issue.labels.length > 0 ? issue.labels.map(oneLine).join(", ") : "<none>";
+    lines.push(`#${options.number}  ${oneLine(issue.title)}`);
+    lines.push(`link:    ${oneLine(link)}`);
+    lines.push(`labels:  ${labels}`);
+    lines.push("");
+    lines.push("summary:");
+    for (const line of extractBodySummary(issue.body).split("\n")) {
+        lines.push(`  ${oneLine(line)}`);
+    }
+    lines.push("");
+    const ac = extractAcceptanceCriteria(issue.body);
+    if (ac.length === 0) {
+        lines.push("acceptance criteria: (thin body / no AC)");
+    }
+    else {
+        lines.push("acceptance criteria:");
+        for (const item of ac) {
+            lines.push(`  - ${oneLine(item)}`);
+        }
+    }
+    lines.push("");
+    if (options.latestDecision !== null) {
+        const d = options.latestDecision;
+        lines.push(`latest decision: ${oneLine(String(d.decision ?? "?"))} at ${oneLine(String(d.timestamp ?? "?"))} by ${oneLine(String(d.actor ?? "?"))}`);
+    }
+    else {
+        lines.push("latest decision: <none -- untriaged>");
+    }
+    lines.push(`active xBRIEF: ${options.inActiveXbrief ? "yes" : "no"}`);
+    lines.push("");
+    lines.push("lean: (agent-owned — not filled by triage:show)");
+    return lines.join("\n");
+}
+//# sourceMappingURL=show.js.map

package/dist/triage/scope/cli.js

@@ -232,9 +232,12 @@ export function runCliCapture(argv) {
             cacheRoot: args.cacheRoot !== undefined ? resolve(args.cacheRoot) : undefined,
         });
         const subHash = subscriptionHash(rules);
+        // When --cache-root is outside the project tree, contain against that root
+        // instead of projectRoot (tests and operators may redirect the cache) (#2869).
         const record = writeCoverageDenominator(path, {
             count: args.count,
             subscriptionHashValue: subHash,
+            projectRoot: args.cacheRoot !== undefined ? resolve(args.cacheRoot) : projectRoot,
         });
         stdout.push(`triage:scope: wrote coverage denominator count=${record.count} ` +
             `subscription-hash=${record.subscriptionHash} path=${path}\n`);

package/dist/triage/scope/coverage.d.ts

@@ -14,6 +14,8 @@ export declare function writeCoverageDenominator(path: string, options: {
     count: number;
     subscriptionHashValue: string;
     fetchedAt?: Date;
+    /** Project (or cache) root for symlink containment (#2869). */
+    projectRoot?: string;
 }): CoverageRecord;
 export declare function readCoverageDenominator(path: string, options: {
     currentHash: string;

package/dist/triage/scope/coverage.js

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
+import { assertWriteTargetSafe } from "../../fs/projection-containment.js";
 import { CACHE_DIR_NAME, COVERAGE_FILENAME, DEFAULT_COVERAGE_TTL_HOURS, ENV_COVERAGE_TTL_HOURS, } from "./constants.js";
 import { parseIso, utcIso, utcNow } from "./time.js";
 export function coveragePath(source, repo, options = {}) {
@@ -29,14 +30,28 @@ export function writeCoverageDenominator(path, options) {
     if (!options.subscriptionHashValue) {
         throw new Error("subscription_hash_value must be a non-empty string");
     }
+    const absPath = resolve(path);
+    // Production CLI always passes projectRoot. When omitted (unit tests with a
+    // bare cacheRoot), walk up to the deepest existing ancestor so containment
+    // can realpath the root before mkdir creates intermediate dirs (#2869).
+    let containmentRoot = options.projectRoot !== undefined ? resolve(options.projectRoot) : dirname(absPath);
+    if (options.projectRoot === undefined) {
+        while (!existsSync(containmentRoot)) {
+            const parent = dirname(containmentRoot);
+            if (parent === containmentRoot)
+                break;
+            containmentRoot = parent;
+        }
+    }
+    assertWriteTargetSafe(containmentRoot, absPath);
     const stamp = utcIso(options.fetchedAt ?? null);
-    mkdirSync(join(path, ".."), { recursive: true });
+    mkdirSync(dirname(absPath), { recursive: true });
     const payload = {
         count: options.count,
         fetched_at: stamp,
         subscription_hash: options.subscriptionHashValue,
     };
-    writeFileSync(path, `${JSON.stringify(payload, Object.keys(payload).sort())}\n`, "utf8");
+    writeFileSync(absPath, `${JSON.stringify(payload, Object.keys(payload).sort())}\n`, "utf8");
     return {
         count: options.count,
         fetchedAt: stamp,

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

@@ -3,6 +3,7 @@ export * from "./code-structure-validate.js";
 export * from "./content-manifest.js";
 export { CANONICAL_SCHEMA_REL, type ContractDriftOptions, type ContractDriftResult, evaluateContractDrift, PUBLISHED_SCHEMA_REL, } from "./contract-drift.js";
 export * from "./cursor-tier1.js";
+export * from "./openclaw-tier1.js";
 export * from "./python-call-scan.js";
 export * from "./rule-ownership-lint.js";
 export * from "./scm-boundary.js";

package/dist/verify-source/index.js

@@ -3,6 +3,7 @@ export * from "./code-structure-validate.js";
 export * from "./content-manifest.js";
 export { CANONICAL_SCHEMA_REL, evaluateContractDrift, PUBLISHED_SCHEMA_REL, } from "./contract-drift.js";
 export * from "./cursor-tier1.js";
+export * from "./openclaw-tier1.js";
 export * from "./python-call-scan.js";
 export * from "./rule-ownership-lint.js";
 export * from "./scm-boundary.js";

package/dist/verify-source/openclaw-tier1.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Deterministic gate: assert that OpenClaw is enumerated as a Tier-1 descriptor
+ * in the swarm Phase 3 capability matrix and that routing accepts openclaw as a
+ * dispatch_provider (#2875). Without this gate the "OpenClaw -> Tier 1" mapping
+ * is prose-trusted; a doc edit that drops the sessions_spawn descriptor would
+ * silently re-open misclassification (OpenClaw falling through to grok-build or
+ * generic-terminal).
+ *
+ * Review-cycle skill markers for OpenClaw Approach 1 are owned by sibling #2876
+ * and are intentionally out of scope for this gate.
+ */
+export interface OpenclawTier1Target {
+    /** Project-root-relative path to the surface file. */
+    readonly path: string;
+    /** Human label for the surface, used in failure output. */
+    readonly label: string;
+    /** Whitespace-normalized substrings that MUST all be present. */
+    readonly markers: readonly string[];
+}
+export declare const OPENCLAW_TIER1_TARGETS: readonly OpenclawTier1Target[];
+export interface OpenclawTier1Finding {
+    readonly path: string;
+    readonly label: string;
+    readonly missingMarkers: readonly string[];
+}
+export interface OpenclawTier1Result {
+    readonly code: 0 | 1 | 2;
+    readonly findings: readonly OpenclawTier1Finding[];
+    readonly message: string;
+    readonly stream: "stdout" | "stderr";
+}
+export interface OpenclawTier1Options {
+    readonly targets?: readonly OpenclawTier1Target[];
+    readonly quiet?: boolean;
+}
+export declare function evaluateOpenclawTier1(projectRoot: string, options?: OpenclawTier1Options): OpenclawTier1Result;
+//# sourceMappingURL=openclaw-tier1.d.ts.map

package/dist/verify-source/openclaw-tier1.js

@@ -0,0 +1,100 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+export const OPENCLAW_TIER1_TARGETS = [
+    {
+        path: "content/skills/deft-directive-swarm/SKILL.md",
+        label: "swarm Phase 3 capability matrix",
+        markers: [
+            "Probe for the OpenClaw `sessions_spawn` tool",
+            "sessions_spawn",
+            "openclaw",
+            "Step 2f: OpenClaw Launch",
+        ],
+    },
+    {
+        path: "packages/core/src/swarm/routing.ts",
+        label: "swarm routing dispatch_provider",
+        // Prefer operative identifiers (function + return), not free-floating prose.
+        markers: [
+            "export function resolveDispatchProvider",
+            'return "openclaw"',
+            "DEFT_HAS_SESSIONS_SPAWN",
+            "ROUTING_GATED_DISPATCH_PROVIDERS",
+        ],
+    },
+    {
+        path: "packages/core/src/swarm/routing-set-cli.ts",
+        label: "swarm:routing-set provider resolution",
+        markers: ["resolveDispatchProvider", "openclaw"],
+    },
+];
+/** Collapse all runs of whitespace to a single space (substring-containment normalization). */
+function normalizeWhitespace(text) {
+    return text.replace(/\s+/g, " ");
+}
+export function evaluateOpenclawTier1(projectRoot, options = {}) {
+    const root = resolve(projectRoot);
+    let isDir = false;
+    try {
+        isDir = statSync(root).isDirectory();
+    }
+    catch {
+        isDir = false;
+    }
+    if (!isDir) {
+        return {
+            code: 2,
+            findings: [],
+            message: `verify_openclaw_tier1: --project-root is not a directory: ${root}\n` +
+                "  Recovery: pass an existing directory path.",
+            stream: "stderr",
+        };
+    }
+    const targets = options.targets ?? OPENCLAW_TIER1_TARGETS;
+    const findings = [];
+    for (const target of targets) {
+        const full = join(root, target.path);
+        if (!existsSync(full)) {
+            return {
+                code: 2,
+                findings: [...findings],
+                message: `verify_openclaw_tier1: required surface file not found: ${target.path}\n` +
+                    "  Recovery: run from the framework source root, or update OPENCLAW_TIER1_TARGETS if the path moved.",
+                stream: "stderr",
+            };
+        }
+        let normalized;
+        try {
+            normalized = normalizeWhitespace(readFileSync(full, { encoding: "utf8" }));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+                code: 2,
+                findings: [...findings],
+                message: `verify_openclaw_tier1: could not read ${target.path}: ${msg}`,
+                stream: "stderr",
+            };
+        }
+        const missing = target.markers.filter((marker) => !normalized.includes(normalizeWhitespace(marker)));
+        if (missing.length > 0) {
+            findings.push({ path: target.path, label: target.label, missingMarkers: missing });
+        }
+    }
+    if (findings.length > 0) {
+        const header = "verify_openclaw_tier1: OpenClaw is not fully enumerated as a Tier-1 descriptor (#2875).\n" +
+            "  Root cause: an OpenClaw agent has a first-class backgroundable sub-agent primitive (sessions_spawn) and\n" +
+            "  is therefore Tier 1 / Approach 1. If the matrix or routing surfaces drop the openclaw descriptor, an\n" +
+            "  OpenClaw session silently degrades to grok-build misclassification or generic-terminal. Re-add the missing marker(s):";
+        const body = findings
+            .map((f) => `  ${f.path} (${f.label}) missing: ${f.missingMarkers.map((m) => `"${m}"`).join(", ")}`)
+            .join("\n");
+        return { code: 1, findings, message: `${header}\n${body}`, stream: "stderr" };
+    }
+    const msg = `verify_openclaw_tier1: OpenClaw enumerated as a Tier-1 descriptor in ${targets.length} surface(s) (#2875).`;
+    if (options.quiet) {
+        return { code: 0, findings: [], message: "", stream: "stdout" };
+    }
+    return { code: 0, findings: [], message: msg, stream: "stdout" };
+}
+//# sourceMappingURL=openclaw-tier1.js.map

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

@@ -108,7 +108,7 @@ function migrateLegacyTree(projectRoot, legacyDir, options) {
         // 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);
+            writeVbriefDeprecationMarker(projectRoot, legacyDir);
         }
         else {
             rmSync(legacyDir, { recursive: true, force: true });
@@ -120,13 +120,17 @@ function migrateLegacyTree(projectRoot, legacyDir, options) {
         throw err;
     }
 }
-/** Idempotently write the legacy-root deprecation marker (#2270). */
-function writeVbriefDeprecationMarker(legacyDir) {
+/** Idempotently write the legacy-root deprecation marker (#2270 / #2869). */
+function writeVbriefDeprecationMarker(projectRoot, legacyDir) {
+    const markerPath = join(legacyDir, VBRIEF_DEPRECATION_MARKER_FILENAME);
+    // Refuse leaf or parent-dir symlink escapes before mkdir/write (#2869).
+    assertWriteTargetSafe(projectRoot, legacyDir);
+    assertWriteTargetSafe(projectRoot, markerPath);
     mkdirSync(legacyDir, { recursive: true });
     if (hasVbriefDeprecationMarker(legacyDir)) {
         return;
     }
-    writeFileSync(join(legacyDir, VBRIEF_DEPRECATION_MARKER_FILENAME), VBRIEF_DEPRECATION_MARKER_BODY, "utf8");
+    writeFileSync(markerPath, VBRIEF_DEPRECATION_MARKER_BODY, "utf8");
 }
 /**
  * Converge a leftover legacy `vbrief/` root to an unambiguous state (#2270).
@@ -147,7 +151,7 @@ export function convergeLegacyVbriefRoot(projectRoot, options) {
         rmSync(legacyDir, { recursive: true, force: true });
         return "removed";
     }
-    writeVbriefDeprecationMarker(legacyDir);
+    writeVbriefDeprecationMarker(projectRoot, legacyDir);
     return "marker";
 }
 function renameOrReplace(src, dest) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.86.0",
+  "version": "0.87.0",
   "description": "TypeScript engine core for the Directive framework.",
   "type": "module",
   "main": "./dist/index.js",
@@ -317,8 +317,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-content": "^0.86.0",
-    "@deftai/directive-types": "^0.86.0",
+    "@deftai/directive-content": "^0.87.0",
+    "@deftai/directive-types": "^0.87.0",
     "archiver": "^8.0.0"
   },
   "scripts": {