@deftai/directive 0.85.0 → 0.86.0

package/dist/dispatch.js

@@ -8,10 +8,12 @@ import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, readSync
 import { homedir, tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { engineInfo, userConfig } from "@deftai/directive-core";
+import { assertWriteTargetSafe } from "@deftai/directive-core/dist/fs/projection-containment.js";
 import { parseInitArgv, runInitDepositCli } from "@deftai/directive-core/init-deposit";
 import { appendAuditLog, disclosureLine, migrateLegacyPolicyKey, PLAN_POLICY_KEY, policyColonInvocation, policySetInvocation, projectDefinitionPath, resolvePolicy, resolveWipCap, setPolicy, } from "@deftai/directive-core/policy";
 import { defaultWhich } from "@deftai/directive-core/scm";
 import { KNOWN_SUBAGENT_BACKEND_IDS, probeSubagentBackends, resolveSwarmSubagentBackend, } from "@deftai/directive-core/swarm";
+import { atomicWriteProjectDefinition } from "@deftai/directive-core/vbrief-build";
 const HANDLER_KEYS = [
     "run",
     "main",
@@ -2035,7 +2037,8 @@ function writeWipCap(projectRoot, cap, actor, note) {
     const { path, data, policyBlock } = loadProjectDefinitionForWrite(projectRoot);
     const previous = policyBlock.wipCap;
     policyBlock.wipCap = cap;
-    writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+    assertWriteTargetSafe(projectRoot, path);
+    atomicWriteProjectDefinition(path, data);
     const changed = previous !== cap;
     const parts = [`actor=${actor}`, `wipCap=${cap}`, `previous=${pyRepr(previous)}`];
     if (note)
@@ -2049,7 +2052,8 @@ function writeSubagentBackend(projectRoot, backendId, actor, note) {
     const { path, data, policyBlock } = loadProjectDefinitionForWrite(projectRoot);
     const previous = policyBlock.swarmSubagentBackend;
     policyBlock.swarmSubagentBackend = backendId;
-    writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+    assertWriteTargetSafe(projectRoot, path);
+    atomicWriteProjectDefinition(path, data);
     const changed = previous !== backendId;
     const parts = [
         `actor=${actor}`,

package/dist/entrypoint.d.ts

@@ -0,0 +1,6 @@
+/**
+ * True when this module is the process entrypoint, including npm bin symlinks.
+ * Node passes the symlink path in argv[1]; compare via realpath on both sides.
+ */
+export declare function isDirectEntrypoint(moduleUrl: string | URL): boolean;
+//# sourceMappingURL=entrypoint.d.ts.map

package/dist/entrypoint.js

@@ -0,0 +1,19 @@
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+/**
+ * True when this module is the process entrypoint, including npm bin symlinks.
+ * Node passes the symlink path in argv[1]; compare via realpath on both sides.
+ */
+export function isDirectEntrypoint(moduleUrl) {
+    const argv1 = process.argv[1];
+    if (argv1 === undefined)
+        return false;
+    try {
+        const modulePath = fileURLToPath(moduleUrl);
+        return realpathSync(argv1) === realpathSync(modulePath);
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=entrypoint.js.map

package/dist/hook-bin.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { fileURLToPath } from "node:url";
+import { isDirectEntrypoint } from "./entrypoint.js";
 import { run } from "./hook-dispatch.js";
 // Keep PreToolUse off the general CLI router's cold path.
 export function main(argv = process.argv.slice(2)) {
     return run(argv);
 }
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+if (isDirectEntrypoint(import.meta.url)) {
     process.exit(main());
 }
 //# sourceMappingURL=hook-bin.js.map

package/dist/vbrief-preflight.d.ts

@@ -2,6 +2,7 @@
 interface ParsedArgs {
     vbriefPath: string | null;
     emitJson: boolean;
+    help?: boolean;
     error?: string;
 }
 /** Parse vbrief-preflight / xbrief:preflight CLI args (#810 / #2449). */

package/dist/vbrief-preflight.js

@@ -1,6 +1,15 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
 import { emitJson, evaluate, PREFLIGHT_USAGE_HINT } from "@deftai/directive-core/preflight";
+const HELP_TEXT = `usage: xbrief:preflight [--vbrief-path PATH | PATH] [--json] [--help]
+
+Implementation-intent gate (#810): exits 0 only when the xBRIEF is in
+xbrief/active/ (or legacy vbrief/active/) AND plan.status == 'running'.
+
+Examples:
+  deft xbrief:preflight -- xbrief/active/<story>.xbrief.json
+  deft xbrief:preflight --vbrief-path xbrief/active/<story>.xbrief.json
+`;
 const PATH_FLAG_NAMES = ["--vbrief-path", "--brief-path", "--xbrief-path"];
 function assignPathFlag(parsed, value) {
     if (value === undefined || value.length === 0) {
@@ -19,15 +28,30 @@ export function parseArgs(argv) {
     };
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
+        if (arg === "--") {
+            continue;
+        }
         if (arg === "--json") {
             parsed.emitJson = true;
             continue;
         }
         if (arg === "--help" || arg === "-h") {
-            return parsed;
+            return { ...parsed, help: true };
         }
         if (PATH_FLAG_NAMES.includes(arg)) {
-            const next = assignPathFlag(parsed, argv[i + 1]);
+            // Task wrappers bake `--vbrief-path {{.CLI_ARGS}}`, so
+            // `task xbrief:preflight -- --help` arrives as `--vbrief-path --help`.
+            const nextToken = argv[i + 1];
+            if (nextToken === "--help" || nextToken === "-h") {
+                return { ...parsed, help: true };
+            }
+            if (nextToken !== undefined && nextToken.startsWith("-")) {
+                return {
+                    ...parsed,
+                    error: "argument --vbrief-path: expected one argument",
+                };
+            }
+            const next = assignPathFlag(parsed, nextToken);
             if (next?.error !== undefined)
                 return next;
             parsed.vbriefPath = next?.vbriefPath ?? null;
@@ -66,6 +90,10 @@ export function parseArgs(argv) {
 /** Run the gate and return the process exit code (parse errors -> 2). */
 export function run(argv) {
     const args = parseArgs(argv);
+    if (args.help) {
+        process.stdout.write(HELP_TEXT);
+        return 0;
+    }
     if (args.error !== undefined) {
         process.stderr.write(`preflight_implementation: ${args.error}\n`);
         return 2;

package/dist/verify-encoding.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 import { evaluate } from "@deftai/directive-core";
+import { isDirectEntrypoint } from "./entrypoint.js";
 /** Parse the verify-encoding CLI args, mirroring the Python argparse surface. */
 export function parseArgs(argv) {
     const parsed = {
@@ -77,10 +77,7 @@ export function run(argv) {
     return result.exitCode;
 }
 // Only execute when invoked directly as a binary (not when imported in tests).
-// Normalize both sides via fileURLToPath so the guard fires on Windows too,
-// where process.argv[1] is a native backslash path and import.meta.url is a
-// forward-slash file:// URL -- a raw `file://${process.argv[1]}` never matches.
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+if (isDirectEntrypoint(import.meta.url)) {
     process.exit(run(process.argv.slice(2)));
 }
 //# sourceMappingURL=verify-encoding.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive",
-  "version": "0.85.0",
+  "version": "0.86.0",
   "description": "Directive CLI — npm install path for the Deft Directive framework.",
   "type": "module",
   "main": "./dist/index.js",
@@ -32,8 +32,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-core": "^0.85.0",
-    "@deftai/directive-content": "^0.85.0"
+    "@deftai/directive-core": "^0.86.0",
+    "@deftai/directive-content": "^0.86.0"
   },
   "scripts": {
     "build": "tsc -b"