@deftai/directive-core 0.85.0 → 0.87.0

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

@@ -1,7 +1,8 @@
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
+import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 import { checkGitClean } from "../migrate-preflight/index.js";
-import { agentsRefreshPlan } from "../platform/agents-md.js";
+import { applyAgentsRefresh } 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, OBSOLETE_FRAMEWORK_NARRATIVE_FILENAME, VBRIEF_DEPRECATION_MARKER_BODY, VBRIEF_DEPRECATION_MARKER_FILENAME, } from "./constants.js";
 import { detectLegacyVbriefLayout, detectXbriefConvergence } from "./detect.js";
@@ -107,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 });
@@ -119,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).
@@ -146,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) {
@@ -157,25 +162,33 @@ function renameOrReplace(src, dest) {
     rmSync(src, { recursive: true, force: true });
 }
 function runAgentsRefresh(projectRoot, frameworkRoot, io) {
-    const plan = agentsRefreshPlan(projectRoot, { frameworkRoot });
-    const state = String(plan.state ?? "unknown");
-    if (state === "current") {
-        io.writeOut("AGENTS.md managed section is current — no changes.\n");
+    try {
+        assertWriteTargetSafe(projectRoot, join(projectRoot, "AGENTS.md"));
+        const { state, wrote, writable } = applyAgentsRefresh(projectRoot, {}, { frameworkRoot });
+        if (state === "current") {
+            io.writeOut("AGENTS.md managed section is current — no changes.\n");
+            return 0;
+        }
+        if (state === "template-missing" || state === "template-malformed" || state === "unreadable") {
+            io.writeErr(`agents:refresh failed: ${state}\n`);
+            return 2;
+        }
+        if (!writable) {
+            io.writeErr("agents:refresh failed: plan produced no new_content\n");
+            return 2;
+        }
+        if (wrote) {
+            io.writeOut(`AGENTS.md updated (state=${state}).\n`);
+        }
         return 0;
     }
-    if (state === "template-missing" || state === "template-malformed" || state === "unreadable") {
-        io.writeErr(`agents:refresh failed: ${state}\n`);
-        return 2;
-    }
-    const newContent = plan.new_content;
-    if (typeof newContent !== "string") {
-        io.writeErr("agents:refresh failed: plan produced no new_content\n");
-        return 2;
+    catch (err) {
+        if (err instanceof ProjectionContainmentError) {
+            io.writeErr(`agents:refresh failed: ${err.message}\n`);
+            return 2;
+        }
+        throw err;
     }
-    const path = String(plan.path ?? join(projectRoot, "AGENTS.md"));
-    writeFileSync(path, newContent, "utf8");
-    io.writeOut(`AGENTS.md updated (state=${state}).\n`);
-    return 0;
 }
 /** Core orchestrator for the consumer xbrief rename (#2110) + convergence (#2270). */
 export function runXbriefMigration(args, _io) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.85.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.85.0",
-    "@deftai/directive-types": "^0.85.0",
+    "@deftai/directive-content": "^0.87.0",
+    "@deftai/directive-types": "^0.87.0",
     "archiver": "^8.0.0"
   },
   "scripts": {