@deftai/directive 0.119.12 → 0.120.0

package/dist/verify-consumer-header-placeholder.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * CLI for verify:consumer-header-placeholder (#4544 Prefer-A).
+ *
+ * Fail closed when product-mutation completion still leaves the unmanaged
+ * AGENTS.md header on the exact scaffold edit-me placeholder. Process-only
+ * and custom headers pass. Returned failure only.
+ */
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluateConsumerHeaderPlaceholderAtRoot } from "@deftai/directive-core/check";
+function takeProjectRootValue(argv, index) {
+    const next = argv[index + 1];
+    if (next === undefined || next.length === 0 || next.startsWith("-")) {
+        return { error: "argument --project-root: expected one argument", next: index };
+    }
+    return { value: next, next: index + 1 };
+}
+/** Parse verify-consumer-header-placeholder CLI args. */
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        quiet: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--quiet") {
+            parsed.quiet = true;
+        }
+        else if (arg === "--project-root") {
+            const taken = takeProjectRootValue(argv, i);
+            if (taken.error !== undefined) {
+                return { ...parsed, error: taken.error };
+            }
+            parsed.projectRoot = taken.value ?? parsed.projectRoot;
+            i = taken.next;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            const value = arg.slice("--project-root=".length);
+            if (value.length === 0 || value.startsWith("-")) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+/** Run the gate and return the process exit code. */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`verify_consumer_header_placeholder: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const result = evaluateConsumerHeaderPlaceholderAtRoot(projectRoot);
+    if (result.message.length > 0 && !args.quiet) {
+        if (result.ok) {
+            process.stdout.write(`${result.message}\n`);
+        }
+        else {
+            process.stderr.write(`${result.message}\n`);
+        }
+    }
+    return result.ok ? 0 : 1;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-consumer-header-placeholder.js.map

package/dist/verify-ownership.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+export interface VerifyOwnershipArgs {
+    projectRoot: string;
+    json: boolean;
+    owner: string | null;
+    error?: string;
+}
+export declare function parseArgs(argv: readonly string[]): VerifyOwnershipArgs;
+export declare function run(argv: readonly string[]): number;
+//# sourceMappingURL=verify-ownership.d.ts.map

package/dist/verify-ownership.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * verify:ownership / verify-ownership (#1617)
+ * Fail-closed check for WSL root-runtime ownership mismatch.
+ */
+import { resolve } from "node:path";
+import { assertProtectedMutationOwnership, evaluateWslOwnershipGuard, ownershipGuardToDict, } from "@deftai/directive-core/platform";
+import { isDirectEntrypoint } from "./entrypoint.js";
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        json: false,
+        owner: null,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--") {
+        }
+        else if (arg === "--json") {
+            parsed.json = true;
+        }
+        else if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--owner") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --owner: expected uid:gid" };
+            }
+            parsed.owner = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--owner=")) {
+            parsed.owner = arg.slice("--owner=".length);
+        }
+        else if (arg === "--help" || arg === "-h") {
+            return { ...parsed, error: "__help__" };
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+const HELP = "usage: deft verify:ownership [--project-root PATH] [--owner uid:gid] [--json]\n" +
+    "Fail closed when WSL root runtime can create root-owned project files (#1617).\n" +
+    "Native Windows/macOS always pass. Mount-pinned DrvFs/9p without metadata passes.\n";
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error === "__help__") {
+        process.stdout.write(HELP);
+        return 0;
+    }
+    if (args.error !== undefined) {
+        process.stderr.write(`verify:ownership: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const seams = { projectRoot, explicitOwner: args.owner };
+    const gate = assertProtectedMutationOwnership(seams);
+    if (args.json) {
+        process.stdout.write(`${JSON.stringify(ownershipGuardToDict(gate.verdict), null, 2)}\n`);
+    }
+    else {
+        process.stdout.write(`${gate.message}\n`);
+    }
+    if (!gate.ok)
+        return gate.exitCode;
+    // Also surface soft warn / override without failing when not blocked.
+    const soft = evaluateWslOwnershipGuard(seams);
+    if (soft.status === "warn" || soft.status === "exempt-override") {
+        if (!args.json) {
+            for (const line of soft.sessionWarnLines)
+                process.stderr.write(`${line}\n`);
+        }
+    }
+    return 0;
+}
+if (isDirectEntrypoint(import.meta.url)) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-ownership.js.map

package/dist/verify-persisted-planning-narratives.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    checkConjunct: boolean;
+    error?: string;
+}
+/** Parse verify:persisted-planning-narratives CLI args (#5176). */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run the Prefer-A first-ship planning-narrative bar. */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=verify-persisted-planning-narratives.d.ts.map

package/dist/verify-persisted-planning-narratives.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+/**
+ * CLI for verify:persisted-planning-narratives (#5176 Prefer-A).
+ *
+ * Default mode is the unconditional setup Phase 2 bar. `--check-conjunct`
+ * mirrors the in-process deft check Prefer-A gate (marker present/unreadable +
+ * empty Overview/tech stack → refuse; missing PD / no marker → pass) so
+ * Taskfile aggregates like check:merge / check:consumer cannot bypass it.
+ */
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { checkRejectsEmptyPlanningNarratives, evaluateCheckPersistedPlanningNarratives, } from "@deftai/directive-core/check";
+import { evaluatePersistedPlanningNarratives } from "@deftai/directive-core/project";
+/** Parse verify:persisted-planning-narratives CLI args (#5176). */
+export function parseArgs(argv) {
+    const parsed = { projectRoot: ".", checkConjunct: false };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--check-conjunct") {
+            parsed.checkConjunct = true;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            process.stdout.write("usage: verify:persisted-planning-narratives [--project-root PATH] [--check-conjunct]\n\n" +
+                "Fail closed when every tracked PROJECT-DEFINITION planning narrative\n" +
+                "(Overview + tech stack) is empty/whitespace (#5176 Prefer-A).\n" +
+                "Default: unconditional setup Phase 2 bar (missing PD → exit 2).\n" +
+                "--check-conjunct: Taskfile/check Prefer-A mirror (marker + empty →\n" +
+                "refuse; missing PD / no marker → pass). Reuse deft project:write-narratives.\n");
+            return parsed;
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+/** Run the Prefer-A first-ship planning-narrative bar. */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`verify:persisted-planning-narratives: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    if (args.checkConjunct) {
+        const planning = evaluateCheckPersistedPlanningNarratives(projectRoot);
+        if (checkRejectsEmptyPlanningNarratives(planning.narratives, planning.productMutation)) {
+            process.stderr.write(`${planning.narratives.message}\n`);
+            return 1;
+        }
+        if (planning.narratives.ok) {
+            process.stdout.write(`${planning.narratives.message}\n`);
+        }
+        else {
+            process.stdout.write("verify:persisted-planning-narratives --check-conjunct: pass " +
+                `(${planning.narratives.cause}; Prefer-A check conjunct does not refuse)\n`);
+        }
+        return 0;
+    }
+    const result = evaluatePersistedPlanningNarratives(projectRoot);
+    if (result.ok) {
+        process.stdout.write(`${result.message}\n`);
+        return 0;
+    }
+    process.stderr.write(`${result.message}\n`);
+    return result.code;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-persisted-planning-narratives.js.map

package/dist/verify-review-monitor.js

@@ -2,7 +2,7 @@
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { bindLivePhaseCorrectWait, evaluateMergePathArm, } from "@deftai/directive-core/dist/pr-watch/main.js";
-import { EXIT_CONFIG_ERROR, EXIT_NOT_READY, evaluateReviewMonitorGate, isTier1, REVIEW_MONITOR_HELP, verifyResultToJson, } from "@deftai/directive-core/review-monitor";
+import { EXIT_CONFIG_ERROR, EXIT_NOT_READY, evaluateReviewMonitorGate, formatApproach1BabysitterOneLiner, isTier1, REVIEW_MONITOR_HELP, spawnRedirect, verifyResultToJson, } from "@deftai/directive-core/review-monitor";
 const CALL_SITES = new Set([
     "solo",
     "swarm-phase5-6",
@@ -134,15 +134,20 @@ export function run(argv) {
     const args = parseVerifyReviewMonitorArgs(argv);
     if (args.help) {
         process.stdout.write(REVIEW_MONITOR_HELP);
-        process.stdout.write("\n#4882 / #5020 merge-path arm observer (optional):\n" +
+        process.stdout.write("\n#4882 / #5020 / #5219 merge-path arm observer (optional):\n" +
             "  --merge-path-arm       Fail closed when neither live wait nor explicit finish\n" +
             "  --live-wait            Require still-running wait evidence for this PR\n" +
             "                         (Tier 1: lease + active polling heartbeat with pid liveness;\n" +
-            "                         lease+flag alone is not armed — #5020)\n" +
+            "                         lease+flag alone is not armed — #5020).\n" +
+            "                         On spawn_subagent hosts, lease platform_primitive must be\n" +
+            "                         spawn_subagent and heartbeat parent_id must match the lease\n" +
+            "                         monitor_agent_id, or pr-wait-mergeable only after local\n" +
+            "                         pr:watch CLEAN attestation — #5219;\n" +
+            "                         parent-shell pr:watch (parent_id=pr-watch) does not arm.\n" +
             "  --explicit-finish      Attest option-C BLOCKED/FAILED finish for this PR\n" +
             "  --sticky-lease         Attest a fresh sticky lease (not sufficient alone)\n" +
-            "  Prefer Approach 1 / native pr:watch or post-CLEAN pr:wait-mergeable-and-merge;\n" +
-            "  homemade line-parsed --json is not an arm.\n");
+            "  Prefer Approach 1 / native pr:watch --monitor-agent-id <id> or post-CLEAN\n" +
+            "  pr:wait-mergeable-and-merge; homemade line-parsed --json is not an arm.\n");
         return 0;
     }
     if (args.error !== undefined) {
@@ -170,6 +175,7 @@ export function run(argv) {
     let arm = null;
     if (args.mergePathArm) {
         // Bind --live-wait to lease (#5018) + process-liveness heartbeat (#5020) on Tier 1.
+        // spawn_subagent identity join is already applied in evaluateReviewMonitorGate (#5219).
         const leaseEvidence = result.monitorRecord !== null;
         const liveBind = bindLivePhaseCorrectWait({
             liveWaitFlag: args.liveWait,
@@ -183,15 +189,38 @@ export function run(argv) {
             explicitFinish: args.explicitFinish,
             stickyLeaseActive: args.stickyLease || leaseEvidence,
         });
-        if (args.liveWait &&
-            !liveBind.livePhaseCorrectWait &&
-            !args.explicitFinish &&
-            !arm.armed &&
-            liveBind.message !== null) {
+        if (args.liveWait && !liveBind.livePhaseCorrectWait && !args.explicitFinish && !arm.armed) {
+            const spawnHost = result.tier.primitive === "spawn_subagent";
+            const lease = result.monitorRecord;
+            let message = liveBind.message;
+            if (spawnHost && lease !== null && lease.platform_primitive !== "spawn_subagent") {
+                message =
+                    `unarmed stand-down: Tier-1 spawn_subagent requires lease ` +
+                        `platform_primitive=spawn_subagent for PR #${args.pr} (#5219); ` +
+                        `got ${lease.platform_primitive}.\n` +
+                        `  ${spawnRedirect(result.tier)}`;
+            }
+            else if (spawnHost &&
+                lease !== null &&
+                lease.platform_primitive === "spawn_subagent" &&
+                liveBind.reason === "missing_process_liveness") {
+                message =
+                    `unarmed stand-down: --live-wait for PR #${args.pr} has spawn_subagent lease ` +
+                        `(monitor_agent_id=${lease.monitor_agent_id}) but no child-bound wait identity ` +
+                        `(heartbeat parent_id must match monitor_agent_id, or pr-wait-mergeable after ` +
+                        `pr:watch CLEAN attestation; start child pr:watch before verify; ` +
+                        `parent-shell pr:watch does not arm) (#5219).\n` +
+                        `  Cheaper path:\n` +
+                        `  ${formatApproach1BabysitterOneLiner(args.pr, lease.monitor_agent_id)}\n` +
+                        `  ${spawnRedirect(result.tier)}`;
+            }
+            else if (message === null) {
+                message = arm.message;
+            }
             arm = {
                 armed: false,
                 reason: "unarmed_stand_down",
-                message: liveBind.message,
+                message,
             };
         }
     }

package/dist/wsl-ownership-guard.d.ts

@@ -0,0 +1,2 @@
+export declare function refuseIfWslOwnershipBlocked(projectRoot: string, writeErr?: (text: string) => void): number | null;
+//# sourceMappingURL=wsl-ownership-guard.d.ts.map

package/dist/wsl-ownership-guard.js

@@ -0,0 +1,15 @@
+/**
+ * Shared live WSL ownership gate for protected mutating CLI entry points (#1617).
+ * Independent of ritual/doctor cache. ownership:doctor/fix are not gated here.
+ */
+import { assertProtectedMutationOwnership } from "@deftai/directive-core/platform";
+export function refuseIfWslOwnershipBlocked(projectRoot, writeErr = (text) => {
+    process.stderr.write(text);
+}) {
+    const gate = assertProtectedMutationOwnership({ projectRoot });
+    if (gate.ok)
+        return null;
+    writeErr(`${gate.message}\n`);
+    return gate.exitCode;
+}
+//# sourceMappingURL=wsl-ownership-guard.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive",
-  "version": "0.119.12",
+  "version": "0.120.0",
   "description": "Directive CLI — npm install path for the Deft Directive framework.",
   "license": "MIT",
   "homepage": "https://deftai.github.io/directive/",
@@ -35,8 +35,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-core": "^0.119.12",
-    "@deftai/directive-content": "^0.119.12"
+    "@deftai/directive-core": "^0.120.0",
+    "@deftai/directive-content": "^0.120.0"
   },
   "scripts": {
     "build": "tsc -b",