@deftai/directive-core 0.86.0 → 0.88.0

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

@@ -0,0 +1,105 @@
+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 (thin skill)",
+        markers: [
+            "Probe for the OpenClaw `sessions_spawn` tool",
+            "sessions_spawn",
+            "openclaw",
+            "host-openclaw.md",
+        ],
+    },
+    {
+        path: "content/skills/deft-directive-swarm/references/host-openclaw.md",
+        label: "swarm OpenClaw host adapter",
+        markers: ["Step 2f: OpenClaw Launch", "sessions_spawn", "openclaw"],
+    },
+    {
+        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,7 +1,8 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.86.0",
+  "version": "0.88.0",
   "description": "TypeScript engine core for the Directive framework.",
+  "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -317,8 +318,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-content": "^0.86.0",
-    "@deftai/directive-types": "^0.86.0",
+    "@deftai/directive-content": "^0.88.0",
+    "@deftai/directive-types": "^0.88.0",
     "archiver": "^8.0.0"
   },
   "scripts": {