@deftai/directive 0.119.8 → 0.119.9

package/dist/cli-router/route-argv.js

@@ -29,6 +29,7 @@ export const SCOPE_LIFECYCLE_VERBS = new Set([
     "block",
     "unblock",
     "stamp-evidence",
+    "bind-clause",
 ]);
 /** pr:* task names that do not hyphenate 1:1 to handler stems. */
 export const PR_VERB_MAP = {
@@ -82,6 +83,8 @@ export const SUBCOMMAND_ROUTES = {
     "policy:enable-directive": ["policy", "enable-directive"],
     "policy:enforce-branches": ["policy", "enforce-branches"],
     "policy:allow-direct-commits": ["policy", "allow-direct-commits"],
+    "policy:allow-destructive-gh-verbs": ["policy", "allow-destructive-gh-verbs"],
+    "policy:enforce-destructive-gh-verbs": ["policy", "enforce-destructive-gh-verbs"],
     "policy:allow-bot-merge": ["policy", "allow-bot-merge"],
     "policy:enable-value-feedback": ["policy", "enable-value-feedback"],
     "policy:disable-host-hooks": ["policy", "disable-host-hooks"],
@@ -207,6 +210,9 @@ function routeNamespaceVerb(ns, verb, rest) {
     if (ns === "scm" && verb === "issue:design-critique-chip") {
         return { kind: "dispatch", argv: ["scm", "issue", "design-critique-chip", ...rest] };
     }
+    if (ns === "scm" && verb === "issue:design-critique-stale-ready") {
+        return { kind: "dispatch", argv: ["scm", "issue", "design-critique-stale-ready", ...rest] };
+    }
     if (ns === "scm" && verb === "issue:work-claim") {
         return { kind: "dispatch", argv: ["scm", "issue", "work-claim", ...rest] };
     }

package/dist/dispatch.d.ts

@@ -10,7 +10,7 @@ export interface DispatchIo {
     writeErr: (text: string) => void;
 }
 /** CLI modules in packages/cli/src (excluding parity harnesses and bin/index). */
-export declare const CLI_MODULE_VERBS: readonly ["agents-refresh", "cache", "check", "capacity-backfill", "capacity-show", "codebase-default-extractor", "codebase-map", "codebase-map-fresh", "codebase-projection-registry", "codebase-provider", "doctor", "install-upgrade", "install-uninstall", "migrate-preflight", "migrate-xbrief", "migrate-category-b", "framework-check-updates", "hook-dispatch", "umbrella-current-shape", "changelog-check", "change-init", "commit-lint", "coverage-hotspots", "policy", "authz", "escalation-cli", "pr-closing-keywords", "pr-merge-readiness", "pr-monitor", "pr-protected-issues", "pr-wait-mergeable", "pr-watch", "pr-finish-loop", "directive-finish-loop", "preflight-cache", "preflight-gh", "probe-session", "release", "release-e2e", "release-publish", "release-rollback", "release-wait-npm", "scope-lifecycle", "scope-record-approved-scope", "scope-record-observable-scope", "scope-record-intent-constraint", "scm-sync-default", "lifecycle-event", "lifecycle-stats", "session-start", "session-ready", "occupancy-steal", "occupancy-release", "occupancy-heartbeat", "occupancy-grant", "plan-sequence", "slice", "subagent-monitor", "toolchain-check", "triage-actions", "triage-bootstrap", "triage-bulk", "triage-classify", "triage-strip-withdrawn", "triage-evaluate", "triage-help", "triage-queue", "triage-reconcile", "triage-refresh", "triage-scope", "triage-scope-drift", "triage-smoketest", "triage-subscribe", "triage-summary", "triage-welcome", "ts-check-lane", "vbrief-activate", "vbrief-build", "vbrief-preflight", "vbrief-reconcile", "vbrief-validate", "vbrief-validation", "xbrief-create", "xbrief-verify", "verify-branch", "verify-encoding", "verify-forward-coverage", "verify-test-boundary", "verify-scope-provenance", "verify-consumer-check-contract", "verify-hooks-installed", "verify-investigation", "verify-judgment-gates", "verify-no-task-runtime", "validate-links", "validate-strategy-output", "verify-biome-config", "verify-bridge-drift", "verify-capacity", "verify-contained-writes", "verify-telemetry-coverage", "verify-content-manifest", "verify-deposit-closure", "verify-consumer-hard-stops", "verify-closing-keywords", "verify-skill-external-fetch-gate", "verify-semantic-single-source", "verify-contract-drift", "verify-cursor-tier1", "verify-openclaw-tier1", "verify-go-freeze", "verify-scm-boundary", "verify-session-ritual", "verify-plan-sequence", "verify-stubs", "verify-xbrief-drift", "verify-spec-prd-fresh", "rule-ownership-lint", "verify-story-ready", "verify-review-monitor", "verify-l4-owner", "verify-subagent-alive", "verify-subagent-steer", "review-monitor-register", "review-monitor-release", "verify-tools", "verify-wip-cap", "verify-orphan-active", "verify-pr-closeout-attestable", "verify-lifecycle-visible", "verify-completed-tracked", "verify-completed-write-guard", "verify-literal-ac", "verify-ac", "verify-agents-md-budget", "verify-agents-md-advisory", "verify-eval-health-relocation", "verify-eval-triggers-relocation", "verify-evaluator-surface", "verify-observable-scope", "verify-intent-constraint", "verify-consumer-test-lane", "eval-health", "eval-run", "eval-report", "eval-triggers"];
+export declare const CLI_MODULE_VERBS: readonly ["agents-refresh", "cache", "check", "capacity-backfill", "capacity-show", "codebase-default-extractor", "codebase-map", "codebase-map-fresh", "codebase-projection-registry", "codebase-provider", "doctor", "install-upgrade", "install-uninstall", "migrate-preflight", "migrate-xbrief", "migrate-category-b", "framework-check-updates", "hook-dispatch", "umbrella-current-shape", "changelog-check", "change-init", "commit-lint", "coverage-hotspots", "policy", "authz", "escalation-cli", "pr-closing-keywords", "pr-merge-readiness", "pr-monitor", "pr-protected-issues", "pr-wait-mergeable", "pr-watch", "pr-finish-loop", "directive-finish-loop", "preflight-cache", "preflight-gh", "probe-session", "release", "release-e2e", "release-publish", "release-rollback", "release-wait-npm", "scope-lifecycle", "scope-record-approved-scope", "scope-record-observable-scope", "scope-record-intent-constraint", "scm-sync-default", "lifecycle-event", "lifecycle-stats", "session-start", "session-ready", "occupancy-steal", "occupancy-release", "occupancy-heartbeat", "occupancy-grant", "plan-sequence", "slice", "subagent-monitor", "toolchain-check", "triage-actions", "triage-bootstrap", "triage-bulk", "triage-classify", "triage-strip-withdrawn", "triage-evaluate", "triage-help", "triage-queue", "triage-reconcile", "triage-refresh", "triage-scope", "triage-scope-drift", "triage-smoketest", "triage-subscribe", "triage-summary", "triage-welcome", "ts-check-lane", "vbrief-activate", "vbrief-build", "vbrief-preflight", "vbrief-reconcile", "vbrief-validate", "vbrief-validation", "xbrief-create", "xbrief-verify", "xbrief-adopt-stored-plan-id", "verify-branch", "verify-encoding", "verify-forward-coverage", "verify-test-boundary", "verify-class-checks", "verify-scope-provenance", "verify-consumer-check-contract", "verify-hooks-installed", "verify-investigation", "verify-judgment-gates", "verify-no-task-runtime", "validate-links", "validate-strategy-output", "verify-biome-config", "verify-bridge-drift", "verify-capacity", "verify-contained-writes", "verify-telemetry-coverage", "verify-content-manifest", "verify-deposit-closure", "verify-consumer-hard-stops", "verify-closing-keywords", "verify-skill-external-fetch-gate", "verify-semantic-single-source", "verify-contract-drift", "verify-cursor-tier1", "verify-openclaw-tier1", "verify-go-freeze", "verify-scm-boundary", "verify-session-ritual", "verify-plan-sequence", "verify-stubs", "verify-xbrief-drift", "verify-spec-prd-fresh", "rule-ownership-lint", "verify-story-ready", "verify-review-monitor", "verify-l4-owner", "verify-subagent-alive", "verify-subagent-steer", "review-monitor-register", "review-monitor-release", "verify-tools", "verify-wip-cap", "verify-orphan-active", "verify-pr-closeout-attestable", "verify-lifecycle-visible", "verify-completed-tracked", "verify-completed-write-guard", "verify-literal-ac", "verify-ac", "verify-agents-md-budget", "verify-agents-md-advisory", "verify-eval-health-relocation", "verify-eval-triggers-relocation", "verify-evaluator-surface", "verify-observable-scope", "verify-intent-constraint", "verify-consumer-test-lane", "eval-health", "eval-run", "eval-report", "eval-triggers"];
 /** Core-only CLI entrypoints without a packages/cli wrapper. */
 export declare const CORE_MODULE_VERBS: readonly ["scm", "scm-readiness", "github-auth-modes", "github-body", "issue-emit", "issue-ingest", "issue-sync-from-xbrief", "reconcile-issues", "swarm-launch", "swarm-complete-cohort", "swarm-finalize-cohort", "swarm-pre-dispatch", "swarm-readiness", "swarm-routing-verify", "swarm-routing-set", "swarm-verify-review-clean", "swarm-worktrees", "framework-commands", "pack-render", "packs-slice", "prd-render", "export-spec", "project-render", "project-write-narratives", "roadmap-render", "rule-map", "spec-render", "spec-validate", "code-structure-validate", "pack-migrate-skills", "pack-migrate-rules", "pack-migrate-strategies", "pack-migrate-patterns", "pack-migrate-swarm-spec", "policy-set", "setup-ghx", "scope-undo", "scope-demote", "scope-decompose", "changelog-resolve-unreleased", "architecture-preflight-sor", "feedback-file", "value-readback", "product-signal", "freshness-report", "decision-write", "decision-list", "docs-impact"];
 /** Colon aliases for triage-actions (mirrors cli-router SUBCOMMAND_ROUTES). */

package/dist/dispatch.js

@@ -111,10 +111,12 @@ export const CLI_MODULE_VERBS = [
     "vbrief-validation",
     "xbrief-create",
     "xbrief-verify",
+    "xbrief-adopt-stored-plan-id",
     "verify-branch",
     "verify-encoding",
     "verify-forward-coverage",
     "verify-test-boundary",
+    "verify-class-checks",
     "verify-scope-provenance",
     "verify-consumer-check-contract",
     "verify-hooks-installed",
@@ -242,6 +244,8 @@ export const POLICY_ACTION_ALIAS_SUBCOMMANDS = {
     "policy:show": "show",
     "policy:enforce-branches": "enforce-branches",
     "policy:allow-direct-commits": "allow-direct-commits",
+    "policy:allow-destructive-gh-verbs": "allow-destructive-gh-verbs",
+    "policy:enforce-destructive-gh-verbs": "enforce-destructive-gh-verbs",
     "policy:allow-bot-merge": "allow-bot-merge",
     "policy:enable-value-feedback": "enable-value-feedback",
     "policy:disable-host-hooks": "disable-host-hooks",
@@ -299,6 +303,7 @@ export const VERB_ALIASES = {
     "verify:encoding": "verify-encoding",
     "verify:forward-coverage": "verify-forward-coverage",
     "verify:test-boundary": "verify-test-boundary",
+    "verify:class-checks": "verify-class-checks",
     "verify:scope-provenance": "verify-scope-provenance",
     "scope:record-approved-scope": "scope-record-approved-scope",
     "scope:record-observable-scope": "scope-record-observable-scope",
@@ -337,6 +342,7 @@ export const VERB_ALIASES = {
     "xbrief:preflight": "vbrief-preflight",
     "xbrief:create": "xbrief-create",
     "xbrief:verify": "xbrief-verify",
+    "xbrief:adopt-stored-plan-id": "xbrief-adopt-stored-plan-id",
     "vbrief:activate": "vbrief-activate",
     "verify:story-ready": "verify-story-ready",
     "verify:review-monitor": "verify-review-monitor",
@@ -478,6 +484,7 @@ const WRAPPER_CLI_STEMS = new Set([
     "vbrief-validation",
     "xbrief-create",
     "xbrief-verify",
+    "xbrief-adopt-stored-plan-id",
 ]);
 function emitCliResult(result, io) {
     if (result.stdout)
@@ -553,6 +560,10 @@ async function loadWrapperCliHandler(stem, io) {
             const { runXbriefVerifyCli } = await import("@deftai/directive-core/xbrief");
             return (argv) => emitCliResult(runXbriefVerifyCli(argv), io);
         }
+        case "xbrief-adopt-stored-plan-id": {
+            const { runAdoptStoredPlanIdCli } = await import("@deftai/directive-core/xbrief");
+            return (argv) => emitCliResult(runAdoptStoredPlanIdCli(argv), io);
+        }
         default:
             throw new Error(`no wrapper handler for ${stem}`);
     }
@@ -2771,6 +2782,10 @@ const CURATED_HELP_GROUPS = [
                 name: "xbrief:verify",
                 summary: "Verify a dense xBRIEF artifact at --out (requires --format); not scope:*",
             },
+            {
+                name: "xbrief:adopt-stored-plan-id",
+                summary: "Set plan.id from the stored plan-id binding; refuse if another artifact has it",
+            },
         ],
     },
     {

package/dist/policy.d.ts

@@ -8,7 +8,7 @@ interface ShowArgs {
     error?: string;
 }
 interface SetArgs {
-    cmd: "show" | "enforce-branches" | "allow-direct-commits" | "allow-bot-merge" | "enable-value-feedback" | "clear-value-feedback" | "set-ceremony-dial" | "disable-host-hooks" | "disable-directive" | "enable-directive" | "resolve";
+    cmd: "show" | "enforce-branches" | "allow-direct-commits" | "allow-destructive-gh-verbs" | "enforce-destructive-gh-verbs" | "allow-bot-merge" | "enable-value-feedback" | "clear-value-feedback" | "set-ceremony-dial" | "disable-host-hooks" | "disable-directive" | "enable-directive" | "resolve";
     confirm: boolean;
     actor: string;
     note: string;

package/dist/policy.js

@@ -6,7 +6,7 @@
 import { existsSync } from "node:fs";
 import { resolve as pathResolve, relative } from "node:path";
 import { fileURLToPath } from "node:url";
-import { ALLOW_BOT_MERGE_CAPABILITY_COST, CEREMONY_DEPTHS, clearValueFeedback, createNoDeftDirectiveFlag, describeShadowedPlanExtension, detectNoDeftDirective, detectShadowedPlanExtensions, disableHostHooks, disclosureLine, enableValueFeedback, FIELD_VALUE_FEEDBACK, FIELD_VALUE_FEEDBACK_CLI_ALIAS, formatValueFeedbackStatusLine, humanMergeDisclosureLine, inspectAllPolicies, inspectOnePolicy, loadProjectDefinition, NO_DEFT_DIRECTIVE_DISABLED_MESSAGE, NO_DEFT_DIRECTIVE_FLAG_NAME, NO_DEFT_DIRECTIVE_INCONSISTENT_MESSAGE, POLICY_AUDIT_NOOP_STDOUT, parseHookHost, policyColonInvocation, projectDefinitionPath, pythonListRepr, pythonStringRepr, registeredPolicyNames, removeNoDeftDirectiveFlag, renderJson, renderText, resolveHumanMergePolicy, resolvePolicy, resolveValueFeedback, setCeremonyDial, setPolicy, setRequireHumanMerge, } from "@deftai/directive-core/policy";
+import { ALLOW_BOT_MERGE_CAPABILITY_COST, ALLOW_DESTRUCTIVE_GH_VERBS_CAPABILITY_COST, CEREMONY_DEPTHS, clearValueFeedback, createNoDeftDirectiveFlag, describeShadowedPlanExtension, detectNoDeftDirective, detectShadowedPlanExtensions, disableHostHooks, disclosureLine, enableValueFeedback, FIELD_VALUE_FEEDBACK, FIELD_VALUE_FEEDBACK_CLI_ALIAS, formatValueFeedbackStatusLine, humanMergeDisclosureLine, inspectAllPolicies, inspectOnePolicy, loadProjectDefinition, NO_DEFT_DIRECTIVE_DISABLED_MESSAGE, NO_DEFT_DIRECTIVE_FLAG_NAME, NO_DEFT_DIRECTIVE_INCONSISTENT_MESSAGE, POLICY_AUDIT_NOOP_STDOUT, parseHookHost, policyColonInvocation, projectDefinitionPath, pythonListRepr, pythonStringRepr, registeredPolicyNames, removeNoDeftDirectiveFlag, renderJson, renderText, resolveHumanMergePolicy, resolvePolicy, resolveValueFeedback, setAllowDestructiveGhVerbs, setCeremonyDial, setPolicy, setRequireHumanMerge, } from "@deftai/directive-core/policy";
 const CAPABILITY_COST_DISCLOSURE = "\u26a0 Capability-cost disclosure -- enabling direct commits to the default " +
     "branch turns OFF the deft branch-protection policy.\n" +
     "  \u2022 Pre-commit + pre-push hooks will no longer block default-branch " +
@@ -114,7 +114,7 @@ export function parseShowArgs(argv) {
 /** Parse argv for the policy CLI (show + set subcommands). */
 export function parseArgs(argv) {
     if (argv.length === 0) {
-        const usage = "usage: policy [show|enforce-branches|allow-direct-commits|allow-bot-merge|enable-value-feedback|clear-value-feedback|set-ceremony-dial|disable-host-hooks|disable-directive|enable-directive|resolve] ...";
+        const usage = "usage: policy [show|enforce-branches|allow-direct-commits|allow-destructive-gh-verbs|enforce-destructive-gh-verbs|allow-bot-merge|enable-value-feedback|clear-value-feedback|set-ceremony-dial|disable-host-hooks|disable-directive|enable-directive|resolve] ...";
         return makeSetError(usage);
     }
     const cmd = argv[0];
@@ -148,6 +148,8 @@ export function parseArgs(argv) {
     }
     if (cmd === "enforce-branches" ||
         cmd === "allow-direct-commits" ||
+        cmd === "allow-destructive-gh-verbs" ||
+        cmd === "enforce-destructive-gh-verbs" ||
         cmd === "allow-bot-merge" ||
         cmd === "enable-value-feedback" ||
         cmd === "clear-value-feedback" ||
@@ -160,19 +162,23 @@ export function parseArgs(argv) {
             ? policyColonInvocation("enforce-branches")
             : cmd === "allow-direct-commits"
                 ? policyColonInvocation("allow-direct-commits")
-                : cmd === "allow-bot-merge"
-                    ? policyColonInvocation("allow-bot-merge")
-                    : cmd === "enable-value-feedback"
-                        ? policyColonInvocation("enable-value-feedback")
-                        : cmd === "clear-value-feedback"
-                            ? policyColonInvocation("clear-value-feedback")
-                            : cmd === "set-ceremony-dial"
-                                ? policyColonInvocation("set-ceremony-dial")
-                                : cmd === "disable-host-hooks"
-                                    ? policyColonInvocation("disable-host-hooks")
-                                    : cmd === "disable-directive"
-                                        ? policyColonInvocation("disable-directive")
-                                        : policyColonInvocation("enable-directive");
+                : cmd === "allow-destructive-gh-verbs"
+                    ? policyColonInvocation("allow-destructive-gh-verbs")
+                    : cmd === "enforce-destructive-gh-verbs"
+                        ? policyColonInvocation("enforce-destructive-gh-verbs")
+                        : cmd === "allow-bot-merge"
+                            ? policyColonInvocation("allow-bot-merge")
+                            : cmd === "enable-value-feedback"
+                                ? policyColonInvocation("enable-value-feedback")
+                                : cmd === "clear-value-feedback"
+                                    ? policyColonInvocation("clear-value-feedback")
+                                    : cmd === "set-ceremony-dial"
+                                        ? policyColonInvocation("set-ceremony-dial")
+                                        : cmd === "disable-host-hooks"
+                                            ? policyColonInvocation("disable-host-hooks")
+                                            : cmd === "disable-directive"
+                                                ? policyColonInvocation("disable-directive")
+                                                : policyColonInvocation("enable-directive");
         let note = "";
         let projectRoot = ".";
         let host;
@@ -476,6 +482,51 @@ function runEnableDirective(args) {
     process.stdout.write("Directive opt-out cleared. Run `directive init` or `directive update` to ensure install.\n");
     return 0;
 }
+/** Allow or re-enforce the #1019 destructive-gh-verb gate. */
+function runDestructiveGhVerbs(args) {
+    const projectRoot = pathResolve(args.projectRoot);
+    const allow = args.cmd === "allow-destructive-gh-verbs";
+    if (allow && !args.confirm) {
+        process.stdout.write(`${ALLOW_DESTRUCTIVE_GH_VERBS_CAPABILITY_COST}\n\n`);
+        process.stdout.write(`Re-run with --confirm to apply: ${policyColonInvocation("allow-destructive-gh-verbs", " -- --confirm")}\n`);
+        return 1;
+    }
+    try {
+        const result = setAllowDestructiveGhVerbs(projectRoot, {
+            allowDestructiveGhVerbs: allow,
+            actor: args.actor,
+            note: args.note,
+        });
+        if (!result.ok) {
+            process.stderr.write(`\u274c ${result.message}\n`);
+            if (result.message.includes("PROJECT-DEFINITION not found")) {
+                const pdRel = relative(projectRoot, projectDefinitionPath(projectRoot));
+                process.stderr.write(`  Recovery: run \`task setup\` to generate ${pdRel}.\n`);
+            }
+            return 2;
+        }
+        process.stdout.write(`\u2713 plan.policy.allowDestructiveGhVerbs=${allow ? "true" : "false"} ` +
+            `(#1019 gate ${allow ? "OFF" : "ON"}).\n`);
+        if (result.changed) {
+            process.stdout.write(`  audit: meta/policy-changes.log :: ${result.auditEntry}\n`);
+        }
+        else {
+            process.stdout.write(`${POLICY_AUDIT_NOOP_STDOUT}\n`);
+        }
+        return 0;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes("PROJECT-DEFINITION not found")) {
+            process.stderr.write(`\u274c ${message}\n`);
+            const pdRel = relative(projectRoot, projectDefinitionPath(projectRoot));
+            process.stderr.write(`  Recovery: run \`task setup\` to generate ${pdRel}.\n`);
+            return 2;
+        }
+        process.stderr.write(`\u274c Config error: ${message}\n`);
+        return 2;
+    }
+}
 /** Allow agent/bot merge by writing requireHumanMerge=false (#1193). */
 function runAllowBotMerge(args) {
     const projectRoot = pathResolve(args.projectRoot);
@@ -539,6 +590,9 @@ export function run(argv) {
     if (args.cmd === "enforce-branches" || args.cmd === "allow-direct-commits") {
         return runSet(args);
     }
+    if (args.cmd === "allow-destructive-gh-verbs" || args.cmd === "enforce-destructive-gh-verbs") {
+        return runDestructiveGhVerbs(args);
+    }
     if (args.cmd === "allow-bot-merge") {
         return runAllowBotMerge(args);
     }

package/dist/preflight-gh.d.ts

@@ -3,6 +3,7 @@ interface ParsedArgs {
     mode?: "self-test" | "command" | "pre-push-stdin";
     command?: string;
     defaultBranches?: Set<string>;
+    projectRoot?: string;
     quiet?: boolean;
     error?: string;
 }

package/dist/preflight-gh.js

@@ -7,11 +7,13 @@
  *   deft-ts preflight-gh --command "<gh ...>"
  *   deft-ts preflight-gh --pre-push-stdin  (reads from stdin)
  *
- * Thin shim -- delegates to @deftai/directive-core/preflight-gh.
+ * Thin shim -- delegates through @deftai/directive-core/preflight
+ * (re-exports the preflight-gh API; vitest already aliases that subpath).
+ * --project-root is consulted by evaluatePrePush / evaluateCommand (#4384).
  */
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
-import { DEFAULT_BRANCHES, ENV_BYPASS, evaluateCommand, runSelfTest, } from "@deftai/directive-core/preflight-gh";
+import { DEFAULT_BRANCHES, evaluateCommand, evaluatePrePush, parsePrePushStdin, runSelfTest, } from "@deftai/directive-core/preflight";
 export function parseArgs(argv) {
     const parsed = { defaultBranches: new Set(DEFAULT_BRANCHES) };
     for (let i = 0; i < argv.length; i++) {
@@ -44,7 +46,11 @@ export function parseArgs(argv) {
             i++;
         }
         else if (arg === "--project-root") {
-            // accepted for parity with preflight_branch.py; ignored here
+            const next = argv[i + 1];
+            if (next === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = next;
             i++;
         }
         else {
@@ -73,7 +79,9 @@ export function run(argv) {
         return code;
     }
     if (args.mode === "command" && args.command !== undefined) {
-        const [code, msg] = evaluateCommand(args.command, branches);
+        const [code, msg] = evaluateCommand(args.command, branches, {
+            projectRoot: args.projectRoot,
+        });
         if (code === 0) {
             if (!quiet)
                 process.stdout.write(`${msg}\n`);
@@ -84,85 +92,19 @@ export function run(argv) {
         return code;
     }
     if (args.mode === "pre-push-stdin") {
-        return runPrePushStdin(branches, quiet);
+        return runPrePushStdin(branches, quiet, args.projectRoot);
     }
     process.stderr.write("preflight-gh: one of --self-test / --command / --pre-push-stdin required\n");
     return 2;
 }
-function parsePrePushLines(text) {
-    return text
-        .split("\n")
-        .map((l) => l.trim())
-        .filter((l) => l.length > 0)
-        .flatMap((l) => {
-        const parts = l.split(/\s+/);
-        if (parts.length !== 4)
-            return [];
-        return [
-            {
-                localRef: parts[0] ?? "",
-                localOid: parts[1] ?? "",
-                remoteRef: parts[2] ?? "",
-                remoteOid: parts[3] ?? "",
-            },
-        ];
-    });
-}
-const ZERO_OID_RE = /^0+$/;
-function evaluatePrePush(refs, branches) {
-    if (refs.length === 0) {
-        return [0, "✓ deft destructive-gh-verb gate (pre-push): no refs in stdin -- nothing to gate."];
-    }
-    const branchesLower = new Set([...branches].map((b) => b.toLowerCase()));
-    const blocked = [];
-    for (const { localRef, localOid, remoteRef, remoteOid } of refs) {
-        const branch = remoteRef.replace(/^refs\/heads\//, "");
-        if (!branchesLower.has(branch.toLowerCase()))
-            continue;
-        if (ZERO_OID_RE.test(remoteOid)) {
-            blocked.push(`create ${branch} (local=${localRef})`);
-        }
-        else if (ZERO_OID_RE.test(localOid)) {
-            blocked.push(`delete ${branch}`);
-        }
-        else {
-            blocked.push(`update ${branch} (local=${localRef})`);
-        }
-    }
-    if (blocked.length === 0) {
-        return [
-            0,
-            "✓ deft destructive-gh-verb gate (pre-push): no pushes to default branches detected -- proceeding.",
-        ];
-    }
-    const bypass = (process.env[ENV_BYPASS] ?? "").trim().toLowerCase();
-    if (["1", "true", "yes", "on"].includes(bypass)) {
-        return [
-            0,
-            `⚠ deft destructive-gh-verb gate (pre-push): default-branch push detected (${blocked.join("; ")}) but ${ENV_BYPASS}=1 is set -- policy bypassed for this invocation.`,
-        ];
-    }
-    return [
-        1,
-        [
-            "❌ deft destructive-gh-verb gate (pre-push): refusing to push directly to the default branch.",
-            `  Detail: ${blocked.join("; ")}`,
-            "",
-            "  How to proceed:",
-            "    • push to a feature branch and open a PR",
-            `    • or set the env-var bypass for this shell:  ${ENV_BYPASS}=1`,
-            "  See scm/github.md (## Destructive gh verbs (#1019)).",
-        ].join("\n"),
-    ];
-}
-function runPrePushStdin(branches, quiet) {
+function runPrePushStdin(branches, quiet, projectRoot) {
     return new Promise((resolve) => {
         const lines = [];
         const rl = createInterface({ input: process.stdin });
         rl.on("line", (l) => lines.push(l));
         rl.on("close", () => {
-            const refs = parsePrePushLines(lines.join("\n"));
-            const [code, msg] = evaluatePrePush(refs, branches);
+            const refs = parsePrePushStdin(lines.join("\n"));
+            const [code, msg] = evaluatePrePush(refs, { branches, projectRoot });
             if (code === 0) {
                 if (!quiet)
                     process.stdout.write(`${msg}\n`);

package/dist/scope-record-intent-constraint.d.ts

@@ -5,6 +5,7 @@ export interface ParsedArgs {
     xbriefPath: string;
     actor: string;
     kind: string;
+    mintedVia: string;
     quiet: boolean;
     confirm: boolean;
     help?: boolean;

package/dist/scope-record-intent-constraint.js

@@ -11,12 +11,18 @@ import { buildIntentConstraintRecord, extractIntentConstraintFromPlan, parseInte
 import { isDirectEntrypoint } from "./entrypoint.js";
 import { refuseMintWhileUatActive, refuseNonInteractiveMint, resolveHumanPresenceMintSeams, } from "./human-presence-mint.js";
 import { isPathInsideRoot } from "./scope-record-approved-scope.js";
+const DEFAULT_MINTED_VIA = "scope:record-intent-constraint";
+const ALLOWED_MINTED_VIA = new Set([DEFAULT_MINTED_VIA, "in-harness-ask"]);
 function usage() {
     return ("usage: scope:record-intent-constraint -- <xbrief-path> --actor <name> --confirm " +
-        "[--kind operator] [--project-root <dir>] [--quiet]\n" +
+        "[--kind operator] [--minted-via in-harness-ask|scope:record-intent-constraint] " +
+        "[--project-root <dir>] [--quiet]\n" +
         '  Writes .deft/intent-constraint/<plan-id>.json from plan["x-directive/intentConstraint"].\n' +
-        "  --actor is display only and never authorizes mint. Mint requires a real TTY, " +
-        "controlling terminal, --confirm, and typed phrase mint (#3110). Agent/CI shells refuse.");
+        "  Attended mid-build (#5010): ask in parent chat; on yes the human runs this verb on a real TTY " +
+        "with --minted-via=in-harness-ask (attestation is not an agent-shell bypass). Commit the record on " +
+        "the delivery-branch merge base, then rebase the implementation branch — same-PR working-tree-only " +
+        "records are not authoritative. Unattended/C1: rewrite or park. --actor is display only. Mint still " +
+        "requires a real TTY, controlling terminal, --confirm, and typed phrase mint (#3110). Agent/CI shells refuse.");
 }
 function extractPlanId(payload) {
     if (payload === null || typeof payload !== "object" || Array.isArray(payload))
@@ -33,6 +39,7 @@ export function parseArgs(argv) {
         xbriefPath: "",
         actor: "",
         kind: "operator",
+        mintedVia: DEFAULT_MINTED_VIA,
         quiet: false,
         confirm: false,
     };
@@ -77,6 +84,16 @@ export function parseArgs(argv) {
         else if (arg?.startsWith("--kind=")) {
             parsed.kind = arg.slice("--kind=".length);
         }
+        else if (arg === "--minted-via") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --minted-via: expected one argument" };
+            parsed.mintedVia = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--minted-via=")) {
+            parsed.mintedVia = arg.slice("--minted-via=".length);
+        }
         else if (arg?.startsWith("-")) {
             return { ...parsed, error: `unrecognized argument: ${arg}` };
         }
@@ -98,6 +115,13 @@ export function parseArgs(argv) {
             error: `argument --actor is required (human operator identity)\n${usage()}`,
         };
     }
+    if (!ALLOWED_MINTED_VIA.has(parsed.mintedVia.trim())) {
+        return {
+            ...parsed,
+            error: `argument --minted-via must be one of: ${[...ALLOWED_MINTED_VIA].join(", ")}\n${usage()}`,
+        };
+    }
+    parsed.mintedVia = parsed.mintedVia.trim();
     return parsed;
 }
 export function run(argv, seams = {}) {
@@ -159,7 +183,7 @@ export function run(argv, seams = {}) {
             kind: args.kind,
             actor: args.actor,
             mintedAt: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
-            mintedVia: "scope:record-intent-constraint",
+            mintedVia: args.mintedVia,
         },
     });
     if ("error" in rec) {

package/dist/scope-record-observable-scope.d.ts

@@ -5,6 +5,7 @@ export interface ParsedArgs {
     xbriefPath: string;
     actor: string;
     kind: string;
+    mintedVia: string;
     quiet: boolean;
     confirm: boolean;
     help?: boolean;

package/dist/scope-record-observable-scope.js

@@ -11,12 +11,18 @@ import { buildObservableScopeRecord, extractObservableChangeFromPlan, parseObser
 import { isDirectEntrypoint } from "./entrypoint.js";
 import { refuseMintWhileUatActive, refuseNonInteractiveMint, resolveHumanPresenceMintSeams, } from "./human-presence-mint.js";
 import { isPathInsideRoot } from "./scope-record-approved-scope.js";
+const DEFAULT_MINTED_VIA = "scope:record-observable-scope";
+const ALLOWED_MINTED_VIA = new Set([DEFAULT_MINTED_VIA, "in-harness-ask"]);
 function usage() {
     return ("usage: scope:record-observable-scope -- <xbrief-path> --actor <name> --confirm " +
-        "[--kind operator] [--project-root <dir>] [--quiet]\n" +
+        "[--kind operator] [--minted-via in-harness-ask|scope:record-observable-scope] " +
+        "[--project-root <dir>] [--quiet]\n" +
         '  Writes .deft/observable-scope/<plan-id>.json from plan["x-directive/observableChange"].\n' +
-        "  --actor is display only and never authorizes mint. Mint requires a real TTY, " +
-        "controlling terminal, --confirm, and typed phrase mint (#3110). Agent/CI shells refuse.");
+        "  Attended mid-build (#5010): ask in parent chat; on yes the human runs this verb on a real TTY " +
+        "with --minted-via=in-harness-ask (attestation is not an agent-shell bypass). Commit the record on " +
+        "the delivery-branch merge base, then rebase the implementation branch — same-PR working-tree-only " +
+        "records are not authoritative. Unattended/C1: rewrite or park. --actor is display only. Mint still " +
+        "requires a real TTY, controlling terminal, --confirm, and typed phrase mint (#3110). Agent/CI shells refuse.");
 }
 function extractPlanId(payload) {
     if (payload === null || typeof payload !== "object" || Array.isArray(payload))
@@ -33,6 +39,7 @@ export function parseArgs(argv) {
         xbriefPath: "",
         actor: "",
         kind: "operator",
+        mintedVia: DEFAULT_MINTED_VIA,
         quiet: false,
         confirm: false,
     };
@@ -77,6 +84,16 @@ export function parseArgs(argv) {
         else if (arg?.startsWith("--kind=")) {
             parsed.kind = arg.slice("--kind=".length);
         }
+        else if (arg === "--minted-via") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --minted-via: expected one argument" };
+            parsed.mintedVia = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--minted-via=")) {
+            parsed.mintedVia = arg.slice("--minted-via=".length);
+        }
         else if (arg?.startsWith("-")) {
             return { ...parsed, error: `unrecognized argument: ${arg}` };
         }
@@ -98,6 +115,13 @@ export function parseArgs(argv) {
             error: `argument --actor is required (human operator identity)\n${usage()}`,
         };
     }
+    if (!ALLOWED_MINTED_VIA.has(parsed.mintedVia.trim())) {
+        return {
+            ...parsed,
+            error: `argument --minted-via must be one of: ${[...ALLOWED_MINTED_VIA].join(", ")}\n${usage()}`,
+        };
+    }
+    parsed.mintedVia = parsed.mintedVia.trim();
     return parsed;
 }
 export function run(argv, seams = {}) {
@@ -161,7 +185,7 @@ export function run(argv, seams = {}) {
             kind: args.kind,
             actor: args.actor,
             mintedAt: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
-            mintedVia: "scope:record-observable-scope",
+            mintedVia: args.mintedVia,
         },
     });
     if ("error" in rec) {

package/dist/verify-class-checks.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    baseRef: string | null;
+    quiet: boolean;
+    error?: string;
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=verify-class-checks.d.ts.map

package/dist/verify-class-checks.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/**
+ * CLI for verify:class-checks (#4980 / #3145 class).
+ */
+import { resolve } from "node:path";
+import { classChecks } from "@deftai/directive-core";
+import { isDirectEntrypoint } from "./entrypoint.js";
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        baseRef: null,
+        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 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 === "--base-ref") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --base-ref: expected one argument" };
+            }
+            parsed.baseRef = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--base-ref=")) {
+            parsed.baseRef = arg.slice("--base-ref=".length);
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`verify_class_checks: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const result = classChecks.evaluateClassChecks(projectRoot, {
+        baseRef: args.baseRef,
+        quiet: args.quiet,
+    });
+    if (result.exitCode === 0) {
+        if (!args.quiet) {
+            process.stdout.write(`${result.message}\n`);
+        }
+    }
+    else {
+        process.stderr.write(`${result.message}\n`);
+    }
+    return result.exitCode;
+}
+if (isDirectEntrypoint(import.meta.url)) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-class-checks.js.map

package/dist/verify-review-monitor.d.ts

@@ -9,6 +9,11 @@ interface ParsedArgs {
     approach3: boolean;
     approach3Warned: boolean;
     emitJson: boolean;
+    /** When true, also run the #4882 merge-path arm observer (attested flags). */
+    mergePathArm: boolean;
+    liveWait: boolean;
+    explicitFinish: boolean;
+    stickyLease: boolean;
     help: boolean;
     error?: string;
 }

package/dist/verify-review-monitor.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { evaluateReviewMonitorGate, REVIEW_MONITOR_HELP, verifyResultToJson, } from "@deftai/directive-core/review-monitor";
+import { 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";
 const CALL_SITES = new Set([
     "solo",
     "swarm-phase5-6",
@@ -18,6 +19,10 @@ export function parseVerifyReviewMonitorArgs(argv) {
         approach3: false,
         approach3Warned: false,
         emitJson: false,
+        mergePathArm: false,
+        liveWait: false,
+        explicitFinish: false,
+        stickyLease: false,
         help: false,
     };
     for (let i = 0; i < argv.length; i += 1) {
@@ -28,6 +33,18 @@ export function parseVerifyReviewMonitorArgs(argv) {
         if (arg === "--json") {
             acc.emitJson = true;
         }
+        else if (arg === "--merge-path-arm") {
+            acc.mergePathArm = true;
+        }
+        else if (arg === "--live-wait") {
+            acc.liveWait = true;
+        }
+        else if (arg === "--explicit-finish") {
+            acc.explicitFinish = true;
+        }
+        else if (arg === "--sticky-lease") {
+            acc.stickyLease = true;
+        }
         else if (arg === "--approach3") {
             acc.approach3 = true;
         }
@@ -117,6 +134,13 @@ export function run(argv) {
     const args = parseVerifyReviewMonitorArgs(argv);
     if (args.help) {
         process.stdout.write(REVIEW_MONITOR_HELP);
+        process.stdout.write("\n#4882 merge-path arm observer (optional):\n" +
+            "  --merge-path-arm       Fail closed when neither live wait nor explicit finish\n" +
+            "  --live-wait            Attest a still-running phase-correct wait for this PR\n" +
+            "                         (Tier 1: bound to gate lease evidence for --pr)\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; homemade line-parsed --json is not an arm.\n");
         return 0;
     }
     if (args.error !== undefined) {
@@ -129,6 +153,8 @@ export function run(argv) {
         process.stderr.write("Try: task verify:review-monitor -- --help\n");
         return 2;
     }
+    // Always evaluate the gate first so --project-root / repo config errors stay
+    // exit 2 even when --merge-path-arm would otherwise fail closed as unarmed.
     const result = evaluateReviewMonitorGate({
         pr: args.pr,
         projectRoot: resolve(args.projectRoot),
@@ -139,15 +165,69 @@ export function run(argv) {
         approach3Warned: args.approach3Warned,
         environ: process.env,
     });
+    let arm = null;
+    if (args.mergePathArm) {
+        // Bind --live-wait to gate-observed lease evidence on Tier 1 for this PR.
+        // Bare flags must not arm when Tier 1 requires a lease and none is present.
+        const leaseEvidence = result.monitorRecord !== null;
+        const liveBound = args.liveWait && (!isTier1(result.tier) || leaseEvidence);
+        arm = evaluateMergePathArm({
+            livePhaseCorrectWait: liveBound,
+            explicitFinish: args.explicitFinish,
+            stickyLeaseActive: args.stickyLease || leaseEvidence,
+        });
+        if (args.liveWait && !liveBound && !args.explicitFinish && !arm.armed) {
+            arm = {
+                armed: false,
+                reason: "unarmed_stand_down",
+                message: `unarmed stand-down: --live-wait attestation unbound to lease evidence ` +
+                    `for PR #${args.pr} (Tier 1); sticky lease alone is not a live arm (#4882)`,
+            };
+        }
+    }
     if (args.emitJson) {
-        process.stdout.write(`${JSON.stringify(verifyResultToJson(result), null, 2)}\n`);
+        const payload = verifyResultToJson(result);
+        if (arm !== null) {
+            payload.merge_path_arm = {
+                armed: arm.armed,
+                reason: arm.reason,
+                message: arm.message,
+                live_wait: args.liveWait,
+                explicit_finish: args.explicitFinish,
+                sticky_lease: args.stickyLease,
+                lease_evidence: result.monitorRecord !== null,
+            };
+            // Combined gate+arm: unarmed fails closed even when the monitor gate is ready.
+            if (!arm.armed && result.exitCode !== EXIT_CONFIG_ERROR) {
+                payload.ready = false;
+                payload.exit_code = EXIT_NOT_READY;
+                // Gate-ready → arm diagnosis; both failing → keep both messages.
+                payload.message = result.exitCode === 0 ? arm.message : `${result.message}\n${arm.message}`;
+            }
+        }
+        process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    }
+    else if (result.exitCode === EXIT_CONFIG_ERROR) {
+        process.stderr.write(`${result.message}\n`);
+    }
+    else if (arm !== null && !arm.armed) {
+        process.stderr.write(`${arm.message}\n`);
     }
     else if (result.exitCode === 0) {
         process.stdout.write(`${result.message}\n`);
+        if (arm !== null) {
+            process.stdout.write(`${arm.message}\n`);
+        }
     }
     else {
         process.stderr.write(`${result.message}\n`);
     }
+    if (result.exitCode === EXIT_CONFIG_ERROR) {
+        return EXIT_CONFIG_ERROR;
+    }
+    if (arm !== null && !arm.armed) {
+        return EXIT_NOT_READY;
+    }
     return result.exitCode;
 }
 if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {

package/dist/verify-session-ritual.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { emitBypassWarning, emitVerifyJson, formatCacheFreshDeferSoftPath, formatRitualRecoveryInstruction, verifySessionRitual, } from "@deftai/directive-core/session";
+import { emitBypassWarning, emitVerifyJson, formatCacheFreshDeferSoftPath, occupancyAwareDenialMessage, verifySessionRitual, } from "@deftai/directive-core/session";
 function parsePosture(value) {
     if (value === "read-only")
         return "read-only";
@@ -121,8 +121,10 @@ export function run(argv, deps = {}) {
         }
     }
     else if (result.code === 1) {
-        const recovery = formatRitualRecoveryInstruction(result.recoveryTier ?? "cold");
-        const lines = [result.message, recovery];
+        const recoveryTier = result.recoveryTier ?? "cold";
+        const lines = [
+            occupancyAwareDenialMessage(projectRoot, result.message, { env: process.env }, recoveryTier),
+        ];
         if (isCacheFreshFailureMessage(result.message)) {
             lines.push(formatCacheFreshDeferSoftPath());
         }

package/dist/windows-bin-ps1.d.ts

@@ -0,0 +1,39 @@
+/** Fallback when package.json cannot be read. Keep aligned with the bin map. */
+export declare const PACKAGE_BIN_NAMES: readonly ["directive", "deft", "deft-ts", "deft-hook", "deft-verify-encoding"];
+/** Node owns these shims. This package must not delete them. */
+export declare const NODE_OWNED_SHIM_NAMES: readonly ["npx", "npm"];
+export interface Ps1ShimRemoval {
+    readonly removed: readonly string[];
+    readonly failed: readonly string[];
+}
+export declare function packageIsUnderNodeModules(pkgDir: string): boolean;
+/** bin-links layout. Valid only when {@link packageIsUnderNodeModules} is true. */
+export declare function nodeModulesDir(pkgDir: string): string;
+/** Same directory bin-links uses for this package root. */
+export declare function linkerBinDir(opts: {
+    readonly pkgDir: string;
+    readonly global: boolean;
+    readonly platform: string;
+}): string;
+export declare function isGlobalInstall(env: Readonly<Record<string, string | undefined>>): boolean;
+export declare function candidateBinDirs(opts: {
+    readonly pkgDir: string;
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly platform: string;
+}): string[];
+export declare function removeGeneratedPs1Shims(opts: {
+    readonly binDir: string;
+    readonly binNames: readonly string[];
+    readonly platform: string;
+    readonly protectedNames?: readonly string[];
+}): Ps1ShimRemoval;
+/** True when cmd-shim text records a target path inside this install. */
+export declare function cmdShimTargetsPackage(cmdText: string, binDir: string, pkgDir: string): boolean;
+export declare function readPackageBinNames(packageJsonText: string): string[];
+export declare function removeInstalledWindowsPs1Shims(opts: {
+    readonly pkgDir: string;
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly platform: string;
+    readonly readText?: (path: string) => string;
+}): Ps1ShimRemoval;
+//# sourceMappingURL=windows-bin-ps1.d.ts.map

package/dist/windows-bin-ps1.js

@@ -0,0 +1,224 @@
+/**
+ * npm's Windows bin linker (cmd-shim) always writes a .ps1 beside the .cmd.
+ * PowerShell selects that .ps1 and stops when script execution is refused, so
+ * the bare name never reaches the .cmd. This runs from postinstall, after
+ * that link, and removes only this package's generated .ps1 files.
+ * A .ps1 is removed only when its sibling .cmd records a target inside this
+ * install, so an ambient PNPM_HOME from another install is left alone.
+ * It does not change npx.ps1, npm.ps1, or the operator's execution policy.
+ */
+import { existsSync, readFileSync, realpathSync, unlinkSync } from "node:fs";
+import { basename, dirname, join, win32 } from "node:path";
+/** Fallback when package.json cannot be read. Keep aligned with the bin map. */
+export const PACKAGE_BIN_NAMES = [
+    "directive",
+    "deft",
+    "deft-ts",
+    "deft-hook",
+    "deft-verify-encoding",
+];
+/** Node owns these shims. This package must not delete them. */
+export const NODE_OWNED_SHIM_NAMES = ["npx", "npm"];
+export function packageIsUnderNodeModules(pkgDir) {
+    const parent = dirname(pkgDir);
+    if (basename(parent) === "node_modules")
+        return true;
+    return basename(dirname(parent)) === "node_modules";
+}
+/** bin-links layout. Valid only when {@link packageIsUnderNodeModules} is true. */
+export function nodeModulesDir(pkgDir) {
+    const scopeOrNm = dirname(pkgDir);
+    if (basename(scopeOrNm) === "node_modules")
+        return scopeOrNm;
+    return dirname(scopeOrNm);
+}
+/** Same directory bin-links uses for this package root. */
+export function linkerBinDir(opts) {
+    const nm = nodeModulesDir(opts.pkgDir);
+    if (!opts.global)
+        return join(nm, ".bin");
+    const prefix = dirname(nm);
+    if (opts.platform === "win32")
+        return prefix;
+    return join(prefix, "bin");
+}
+export function isGlobalInstall(env) {
+    return env.npm_config_global === "true";
+}
+function dirKey(dir, platform) {
+    const norm = dir.replace(/[\\/]+/g, "/");
+    if (platform === "win32")
+        return norm.toLowerCase();
+    return norm;
+}
+function ancestorBinDirs(pkgDir, stopDir, platform) {
+    const stop = dirKey(stopDir, platform);
+    const start = dirKey(pkgDir, platform);
+    const stopPrefix = stop.endsWith("/") ? stop : `${stop}/`;
+    if (start !== stop && !start.startsWith(stopPrefix)) {
+        return [join(stopDir, "node_modules", ".bin")];
+    }
+    const out = [];
+    let dir = pkgDir;
+    for (;;) {
+        out.push(join(dir, "node_modules", ".bin"));
+        if (dirKey(dir, platform) === stop)
+            break;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return out;
+}
+export function candidateBinDirs(opts) {
+    const global = isGlobalInstall(opts.env);
+    const dirs = [];
+    if (packageIsUnderNodeModules(opts.pkgDir)) {
+        dirs.push(linkerBinDir({ pkgDir: opts.pkgDir, global, platform: opts.platform }));
+    }
+    if (global) {
+        const prefix = opts.env.npm_config_prefix;
+        if (prefix !== undefined && prefix.length > 0) {
+            dirs.push(opts.platform === "win32" ? prefix : join(prefix, "bin"));
+        }
+        // Candidate only. Removal still requires the .cmd to target this install.
+        const pnpmHome = opts.env.PNPM_HOME;
+        if (pnpmHome !== undefined && pnpmHome.length > 0)
+            dirs.push(pnpmHome);
+    }
+    else {
+        const localPrefix = opts.env.npm_config_local_prefix;
+        if (localPrefix !== undefined && localPrefix.length > 0) {
+            dirs.push(...ancestorBinDirs(opts.pkgDir, localPrefix, opts.platform));
+        }
+    }
+    const seen = new Set();
+    const out = [];
+    for (const dir of dirs) {
+        const key = dirKey(dir, opts.platform);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(dir);
+    }
+    return out;
+}
+function isSafeBinName(name) {
+    if (name.length === 0)
+        return false;
+    if (name.includes("/") || name.includes("\\") || name.includes(".."))
+        return false;
+    return true;
+}
+export function removeGeneratedPs1Shims(opts) {
+    if (opts.platform !== "win32")
+        return { removed: [], failed: [] };
+    const protect = new Set((opts.protectedNames ?? NODE_OWNED_SHIM_NAMES).map((name) => name.toLowerCase()));
+    const removed = [];
+    const failed = [];
+    for (const name of opts.binNames) {
+        if (!isSafeBinName(name) || protect.has(name.toLowerCase()))
+            continue;
+        const ps1 = join(opts.binDir, `${name}.ps1`);
+        const cmd = join(opts.binDir, `${name}.cmd`);
+        if (!existsSync(cmd) || !existsSync(ps1))
+            continue;
+        try {
+            unlinkSync(ps1);
+            removed.push(ps1);
+        }
+        catch {
+            failed.push(ps1);
+        }
+    }
+    return { removed, failed };
+}
+function normalizedWinPath(p) {
+    const norm = win32.normalize(p).replace(/[\\/]+/g, "\\");
+    const trimmed = norm.length > 3 && norm.endsWith("\\") ? norm.slice(0, -1) : norm;
+    return trimmed.toLowerCase();
+}
+function pathIsInside(root, target) {
+    const rootKey = normalizedWinPath(root);
+    const targetKey = normalizedWinPath(target);
+    return targetKey === rootKey || targetKey.startsWith(`${rootKey}\\`);
+}
+/** cmd-shim text is Windows-shaped. realpath needs host separators or a junction never matches. */
+function hostPath(p) {
+    return p.replace(/\\/g, "/");
+}
+function realpathIsInside(root, target) {
+    try {
+        return pathIsInside(realpathSync(hostPath(root)), realpathSync(hostPath(target)));
+    }
+    catch {
+        return false;
+    }
+}
+/** True when cmd-shim text records a target path inside this install. */
+export function cmdShimTargetsPackage(cmdText, binDir, pkgDir) {
+    const re = /%(?:dp0%|~dp0)(?:\\+|\/+)([^"\r\n\s]+)/gi;
+    for (const match of cmdText.matchAll(re)) {
+        const rel = match[1];
+        if (rel === undefined || rel.length === 0)
+            continue;
+        const resolved = win32.normalize(win32.join(binDir, rel.replace(/\//g, "\\")));
+        if (pathIsInside(pkgDir, resolved) || realpathIsInside(pkgDir, resolved))
+            return true;
+    }
+    return false;
+}
+function cmdLinksCurrentInstall(binDir, name, pkgDir) {
+    if (!isSafeBinName(name))
+        return false;
+    let text;
+    try {
+        text = readFileSync(join(binDir, `${name}.cmd`), "utf8");
+    }
+    catch {
+        return false;
+    }
+    return cmdShimTargetsPackage(text, binDir, pkgDir);
+}
+export function readPackageBinNames(packageJsonText) {
+    let parsed;
+    try {
+        parsed = JSON.parse(packageJsonText);
+    }
+    catch {
+        return [];
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return [];
+    const bin = parsed.bin;
+    if (bin === null || typeof bin !== "object" || Array.isArray(bin))
+        return [];
+    return Object.keys(bin);
+}
+export function removeInstalledWindowsPs1Shims(opts) {
+    if (opts.platform !== "win32")
+        return { removed: [], failed: [] };
+    const readText = opts.readText ?? ((path) => readFileSync(path, "utf8"));
+    let names;
+    try {
+        names = readPackageBinNames(readText(join(opts.pkgDir, "package.json")));
+    }
+    catch {
+        names = PACKAGE_BIN_NAMES;
+    }
+    const removed = [];
+    const failed = [];
+    for (const binDir of candidateBinDirs(opts)) {
+        const linked = names.filter((name) => cmdLinksCurrentInstall(binDir, name, opts.pkgDir));
+        const result = removeGeneratedPs1Shims({
+            binDir,
+            binNames: linked,
+            platform: opts.platform,
+        });
+        removed.push(...result.removed);
+        failed.push(...result.failed);
+    }
+    return { removed, failed };
+}
+//# sourceMappingURL=windows-bin-ps1.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive",
-  "version": "0.119.8",
+  "version": "0.119.9",
   "description": "Directive CLI — npm install path for the Deft Directive framework.",
   "license": "MIT",
   "homepage": "https://deftai.github.io/directive/",
@@ -22,7 +22,8 @@
   },
   "files": [
     "dist/**/*.js",
-    "dist/**/*.d.ts"
+    "dist/**/*.d.ts",
+    "scripts/remove-windows-ps1-shims.mjs"
   ],
   "repository": {
     "type": "git",
@@ -34,10 +35,11 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-core": "^0.119.8",
-    "@deftai/directive-content": "^0.119.8"
+    "@deftai/directive-core": "^0.119.9",
+    "@deftai/directive-content": "^0.119.9"
   },
   "scripts": {
-    "build": "tsc -b"
+    "build": "tsc -b",
+    "postinstall": "node ./scripts/remove-windows-ps1-shims.mjs"
   }
 }

package/scripts/remove-windows-ps1-shims.mjs

@@ -0,0 +1,26 @@
+/**
+ * postinstall entry (#4654). The published tarball includes dist/.
+ * A workspace install before tsc has no linked shims yet, so a missing
+ * dist file is a no-op rather than a failed install.
+ */
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+const entry = join(pkgDir, "dist", "windows-bin-ps1.js");
+
+if (existsSync(entry)) {
+  const mod = await import(pathToFileURL(entry).href);
+  const result = mod.removeInstalledWindowsPs1Shims({
+    pkgDir,
+    env: process.env,
+    platform: process.platform,
+  });
+  if (result.failed.length > 0) {
+    process.stderr.write(
+      `remove-windows-ps1-shims: could not remove ${result.failed.join(", ")}\n`,
+    );
+    process.exitCode = 1;
+  }
+}