@deftai/directive-core 0.79.0 → 0.79.1

package/dist/hooks/dispatcher.d.ts

@@ -6,7 +6,7 @@ export type HookHost = (typeof HOOK_HOSTS)[number];
 export declare const HOOK_EVENTS: readonly ["session.start", "tool.before"];
 export type HookEvent = (typeof HOOK_EVENTS)[number];
 export type HookVerdict = "allow" | "deny";
-export type HookDecisionCode = "session-start" | "session-start-degraded" | "not-direct-write" | "invalid-input" | "ritual-not-ready" | "scope-not-ready" | "write-ready";
+export type HookDecisionCode = "session-start" | "session-start-degraded" | "not-direct-write" | "invalid-input" | "ritual-not-ready" | "scope-not-ready" | "write-propose-ready" | "write-ready";
 export interface HookDecision {
     readonly verdict: HookVerdict;
     readonly code: HookDecisionCode;
@@ -33,6 +33,18 @@ export interface HookPolicySeams {
     };
 }
 export declare function hookToolName(payload: unknown): string | null;
+/**
+ * Best-effort write-target path from host PreToolUse payloads (#2625).
+ * Hosts disagree on nesting (`tool_input.file_path` vs top-level `path`).
+ */
+export declare function hookWriteTargetPath(payload: unknown): string | null;
+/** POSIX-ish project-relative path for lifecycle matching. */
+export declare function toProjectRelativePosix(projectRoot: string, targetPath: string): string;
+/**
+ * Proposing a scope under xbrief/proposed/ (or legacy vbrief/proposed/) is
+ * planning, not implementation dispatch — exempt from the active-scope gate (#2625).
+ */
+export declare function isProposedLifecycleWrite(projectRoot: string, targetPath: string | null): boolean;
 export declare function projectRootFromHookPayload(payload: unknown, fallback: string): string;
 export declare function isHookHost(value: string): value is HookHost;
 export declare function isHookEvent(value: string): value is HookEvent;

package/dist/hooks/dispatcher.js

@@ -1,4 +1,5 @@
-import { resolve } from "node:path";
+import { relative, resolve, sep } from "node:path";
+import { hasArtifactSuffix } from "../layout/resolve.js";
 import { runSessionStartHookWrite } from "../session/session-start-hook.js";
 import { inspectSessionRitual } from "../session/verify-session-ritual.js";
 import { inspectActiveScope } from "./scope.js";
@@ -24,6 +25,39 @@ export function hookToolName(payload) {
         return null;
     return firstString(input.tool_name, input.toolName, input.tool);
 }
+/**
+ * Best-effort write-target path from host PreToolUse payloads (#2625).
+ * Hosts disagree on nesting (`tool_input.file_path` vs top-level `path`).
+ */
+export function hookWriteTargetPath(payload) {
+    const input = record(payload);
+    if (input === null)
+        return null;
+    const toolInput = record(input.tool_input) ?? record(input.toolInput) ?? record(input.input);
+    return firstString(toolInput?.file_path, toolInput?.filePath, toolInput?.path, input.file_path, input.filePath, input.path);
+}
+/** POSIX-ish project-relative path for lifecycle matching. */
+export function toProjectRelativePosix(projectRoot, targetPath) {
+    const abs = resolve(projectRoot, targetPath);
+    const rel = relative(resolve(projectRoot), abs);
+    return rel.split(sep).join("/");
+}
+/**
+ * Proposing a scope under xbrief/proposed/ (or legacy vbrief/proposed/) is
+ * planning, not implementation dispatch — exempt from the active-scope gate (#2625).
+ */
+export function isProposedLifecycleWrite(projectRoot, targetPath) {
+    if (targetPath === null || targetPath.trim().length === 0)
+        return false;
+    const posix = toProjectRelativePosix(projectRoot, targetPath);
+    // resolve()+relative() collapses mid-path `..`; only outside-root `..` remains.
+    if (posix.startsWith(".."))
+        return false;
+    const base = posix.includes("/") ? posix.slice(posix.lastIndexOf("/") + 1) : posix;
+    if (!hasArtifactSuffix(base))
+        return false;
+    return posix.startsWith("xbrief/proposed/") || posix.startsWith("vbrief/proposed/");
+}
 export function projectRootFromHookPayload(payload, fallback) {
     const input = record(payload);
     if (input === null)
@@ -124,6 +158,20 @@ export function decideHook(input, seams = {}) {
             "Recovery: run `deft session:start`, then " +
             "`deft verify:session-ritual -- --tier=gated`.");
     }
+    const writeTarget = hookWriteTargetPath(input.payload);
+    if (isProposedLifecycleWrite(projectRoot, writeTarget)) {
+        return {
+            verdict: "allow",
+            code: "write-propose-ready",
+            event: input.event,
+            host: input.host,
+            toolName,
+            projectRoot,
+            message: `Directive write gate allowed ${toolName} for a proposed lifecycle xBRIEF ` +
+                "(planning write; active scope not required).",
+            scopePath: null,
+        };
+    }
     let scope;
     try {
         scope = (seams.inspectScope ?? inspectActiveScope)(projectRoot);
@@ -132,8 +180,15 @@ export function decideHook(input, seams = {}) {
         scope = { ready: false, path: null, message: String(cause) };
     }
     if (!scope.ready) {
-        return deny(input, "scope-not-ready", toolName, `Directive denied ${toolName}: ${scope.message} ` +
-            "Recovery: run `deft scope:activate -- <path>` for the approved xBRIEF.");
+        const relTarget = writeTarget !== null ? toProjectRelativePosix(projectRoot, writeTarget) : null;
+        const proposedPathHint = relTarget !== null &&
+            (relTarget.startsWith("xbrief/proposed/") || relTarget.startsWith("vbrief/proposed/"))
+            ? " For a new proposal under xbrief/proposed/, include a lifecycle artifact " +
+                "filename (*.xbrief.json) in the Write/Edit payload so the gate can exempt " +
+                "planning writes (#2625)."
+            : " Recovery: run `deft scope:activate -- <path>` for the approved xBRIEF, " +
+                "or Write a new proposal to xbrief/proposed/*.xbrief.json (planning exemption).";
+        return deny(input, "scope-not-ready", toolName, `Directive denied ${toolName}: ${scope.message}${proposedPathHint}`);
     }
     return {
         verdict: "allow",

package/dist/intake/reconcile-issues.js

@@ -684,7 +684,12 @@ export function applyLifecycleFixes(vbriefDir, report, projectRoot = null) {
         mkdirSync(join(vbriefDir, destFolder), { recursive: true });
         try {
             statSync(dst);
-            failures.push(`target already exists in ${destFolder}/: ${filename}`);
+            // Destination already holds this basename (#2622). Treat as already-terminal
+            // and continue the sweep. Do not unlink the source — a same-basename collision
+            // can be a non-identical artifact; leave removal to the operator / git.
+            process.stderr.write(`reconcile: skipped ${relPath} — already present in ${destFolder}/ (#2622); ` +
+                "left source in place for manual cleanup\n");
+            skipped += 1;
             continue;
         }
         catch {

package/dist/pr-wait-mergeable/wrappers.d.ts

@@ -17,6 +17,15 @@ export interface CaptureExecOptions {
 }
 /** UTF-8-safe subprocess capture via spawnSync (no shell) — mirrors #1366. */
 export declare function captureExec(executable: string, args: readonly string[], timeoutMs: number, options?: CaptureExecOptions): CaptureExecResult;
+/**
+ * Resolve a CLI entry script for subprocess spawn (#2615).
+ *
+ * Published npm layout nests `@deftai/directive-core` under `@deftai/directive`,
+ * so the old `../../../cli/dist` relative path resolved to a non-existent
+ * `@deftai/cli` sibling. Prefer the published package root, then monorepo path,
+ * then nested `@deftai/directive/dist`.
+ */
+export declare function cliScriptPath(name: string): string;
 export interface RunProtectedCheckOptions {
     readonly nodeExecutable?: string;
     readonly timeout?: number;

package/dist/pr-wait-mergeable/wrappers.js

@@ -1,4 +1,6 @@
 import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveBinary } from "../scm/binary.js";
@@ -40,9 +42,36 @@ export function captureExec(executable, args, timeoutMs, options = {}) {
         stderr: typeof result.stderr === "string" ? result.stderr : "",
     };
 }
-function cliScriptPath(name) {
+/**
+ * Resolve a CLI entry script for subprocess spawn (#2615).
+ *
+ * Published npm layout nests `@deftai/directive-core` under `@deftai/directive`,
+ * so the old `../../../cli/dist` relative path resolved to a non-existent
+ * `@deftai/cli` sibling. Prefer the published package root, then monorepo path,
+ * then nested `@deftai/directive/dist`.
+ */
+export function cliScriptPath(name) {
+    const script = `${name}.js`;
     const here = dirname(fileURLToPath(import.meta.url));
-    return resolve(here, "../../../cli/dist", `${name}.js`);
+    const candidates = [];
+    try {
+        const require = createRequire(import.meta.url);
+        const pkgJson = require.resolve("@deftai/directive/package.json");
+        candidates.push(resolve(dirname(pkgJson), "dist", script));
+    }
+    catch {
+        // Core does not declare a runtime dependency on the CLI package; ignore.
+    }
+    // Monorepo: packages/core/dist/pr-wait-mergeable -> packages/cli/dist
+    candidates.push(resolve(here, "../../../cli/dist", script));
+    // npm nested: .../directive/node_modules/@deftai/directive-core/dist/... -> .../directive/dist
+    candidates.push(resolve(here, "../../../../dist", script));
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    // ENOENT path for actionable errors — monorepo layout is the stable fallback.
+    return resolve(here, "../../../cli/dist", script);
 }
 /** Invoke pr-protected-issues CLI and return (returncode, stdout, stderr). */
 export function runProtectedCheck(prNumber, repo, protectedIssues, options = {}) {

package/dist/release/constants.js

@@ -64,6 +64,8 @@ export const RELEASE_HELP = "usage: release [-h] [--dry-run] [--skip-tag] [--ski
     "                        Acknowledge a hairline coverage miss: Step 5 passes\n" +
     "                        only when metrics sit below the 85% goal and this\n" +
     "                        flag cites an operator-owned issue number (#2573).\n" +
+    "                        PowerShell: use --allow-coverage-debt=N (no bare #)\n" +
+    '                        or quote "#N"; unquoted # starts a comment (#2621).\n' +
     "  --skip-ci             Skip Step 3 (task ci:local / task check fallback).\n" +
     "                        Used by `task release:e2e` to keep wall-clock\n" +
     "                        manageable inside the auto-created temp repo (CI\n" +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.79.0",
+  "version": "0.79.1",
   "description": "TypeScript engine core for the Directive framework.",
   "type": "module",
   "main": "./dist/index.js",
@@ -305,8 +305,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-content": "^0.79.0",
-    "@deftai/directive-types": "^0.79.0",
+    "@deftai/directive-content": "^0.79.1",
+    "@deftai/directive-types": "^0.79.1",
     "archiver": "^8.0.0"
   },
   "scripts": {