@deftai/directive-runtime 0.128.0 → 0.129.0

package/dist/contract-entry.js

@@ -61,6 +61,8 @@ export async function handleContractEntrypoint(argv) {
             operation: operation,
             from,
             root,
+            // Explicit pre-write operator force only (#5837); self-complete never forces.
+            forceGitHooks: hasFlag(argv, "--force-githooks"),
         });
         process.stdout.write(`${JSON.stringify(result)}\n`);
         if (result.conflicts.length > 0)

package/dist/setup-wiring.d.ts

@@ -84,10 +84,23 @@ export declare function ensureHostHooks(projectRoot: string, hostHooksPolicy?: H
 export declare const PRE_PUSH_BOUND_PRE_PR_MARKER = "deft:pre-pr-bound-push-v1";
 /** AC8.6 / AC2.5 / F-008 — disclosed when hooks files exist but core.hooksPath cannot activate. */
 export declare const GIT_HOOKS_INACTIVE_NO_GIT = "Git hooks inactive until git init + eligible repair/self-complete (core.hooksPath not set)";
-export declare function ensureGitHooks(projectRoot: string): {
+/**
+ * True when `rel` is tracked by git in `projectRoot` (#5837). Any git failure
+ * (no repo, no git binary) reads as untracked, which keeps the replace path lawful.
+ */
+export declare function isGitTrackedPath(projectRoot: string, rel: string): boolean;
+/** Disclosure for a tracked divergent managed hook kept in place (#5837). */
+export declare function formatTrackedHookPreserved(rel: string): string;
+export interface EnsureGitHooksOptions {
+    /** Explicit pre-write operator force: replace tracked divergent managed hooks (#5837). */
+    readonly forceTrackedReplace?: boolean;
+}
+export declare function ensureGitHooks(projectRoot: string, options?: EnsureGitHooksOptions): {
     created: string[];
     modified: string[];
     conflicts: string[];
+    /** Tracked divergent managed hooks kept in place; a non-failure outcome (#5837). */
+    preserved: string[];
     /** True only when core.hooksPath is relative .githooks (AC9.9). */
     hooksPathActive: boolean;
     /** Human disclosure when hooks are not live; null when active. */

package/dist/setup-wiring.js

@@ -740,10 +740,31 @@ function isOurGitHookBody(rel, body) {
 const EXECUTABLE_GITHOOKS = new Set([".githooks/pre-commit", ".githooks/pre-push"]);
 /** AC8.6 / AC2.5 / F-008 — disclosed when hooks files exist but core.hooksPath cannot activate. */
 export const GIT_HOOKS_INACTIVE_NO_GIT = "Git hooks inactive until git init + eligible repair/self-complete (core.hooksPath not set)";
-export function ensureGitHooks(projectRoot) {
+/**
+ * True when `rel` is tracked by git in `projectRoot` (#5837). Any git failure
+ * (no repo, no git binary) reads as untracked, which keeps the replace path lawful.
+ */
+export function isGitTrackedPath(projectRoot, rel) {
+    try {
+        execFileSync("git", ["-C", projectRoot, "ls-files", "--error-unmatch", "--", rel], {
+            stdio: ["ignore", "ignore", "ignore"],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Disclosure for a tracked divergent managed hook kept in place (#5837). */
+export function formatTrackedHookPreserved(rel) {
+    return `${rel}: tracked managed hook differs from the template; kept (not a failure). Review and pass --force-githooks to setup to replace it (#5837)`;
+}
+export function ensureGitHooks(projectRoot, options = {}) {
     const created = [];
     const modified = [];
     const conflicts = [];
+    const preserved = [];
+    const force = options.forceTrackedReplace === true;
     const files = [
         { rel: ".githooks/_directive-run.sh", body: GITHOOK_HELPER },
         { rel: ".githooks/pre-commit", body: PRE_COMMIT },
@@ -756,6 +777,12 @@ export function ensureGitHooks(projectRoot) {
             conflicts.push(`${file.rel}: existing hook is not Directive-managed; refusing to overwrite (chain or remove manually)`);
             continue;
         }
+        // Tracked divergent preserve (#5837): never overwrite a committed hook body,
+        // even a Directive-managed one, unless the operator forced the replace.
+        if (prior !== null && prior !== next && !force && isGitTrackedPath(projectRoot, file.rel)) {
+            preserved.push(formatTrackedHookPreserved(file.rel));
+            continue;
+        }
         // Refuse-to-downgrade: marker-aware installer will not replace a newer enrolled
         // pre-push arm with an older body that lacks the monotonic marker (#5804).
         if (file.rel === ".githooks/pre-push" &&
@@ -802,7 +829,10 @@ export function ensureGitHooks(projectRoot) {
             catch {
                 stillReferenced = true;
             }
-            if (!stillReferenced) {
+            if (!stillReferenced && !force && isGitTrackedPath(projectRoot, legacyHelperRel)) {
+                preserved.push(formatTrackedHookPreserved(legacyHelperRel));
+            }
+            else if (!stillReferenced) {
                 try {
                     const rem = containedRemove({ root: projectRoot, target: legacyHelperRel });
                     if (rem.removed)
@@ -847,7 +877,7 @@ export function ensureGitHooks(projectRoot) {
             inactiveDisclosure = `Git hooks inactive: core.hooksPath is '${current}' (not .githooks)`;
         }
     }
-    return { created, modified, conflicts, hooksPathActive, inactiveDisclosure };
+    return { created, modified, conflicts, preserved, hooksPathActive, inactiveDisclosure };
 }
 const MINIMAL_TASKFILE = `version: '3'
 

package/dist/setup.d.ts

@@ -11,6 +11,8 @@ export interface SetupResult {
     readonly modified: string[];
     readonly removed: string[];
     readonly conflicts: string[];
+    /** Tracked divergent managed hooks kept in place; non-failure, present only when non-empty (#5837). */
+    readonly preserved?: string[];
     readonly message: string;
 }
 /**
@@ -22,6 +24,8 @@ export declare function runSetup(options: {
     readonly operation: SetupOperation;
     readonly from: string;
     readonly root: string;
+    /** Explicit pre-write operator force to replace tracked divergent managed hooks (#5837). */
+    readonly forceGitHooks?: boolean;
 }): SetupResult;
 export declare function setupChangeCount(result: SetupResult): number;
 //# sourceMappingURL=setup.d.ts.map

package/dist/setup.js

@@ -223,6 +223,8 @@ function buildOwnershipArtifacts(projectRoot) {
  */
 export function runSetup(options) {
     const { operation, from, root } = options;
+    let preserved = [];
+    const withPreserved = () => (preserved.length > 0 ? { preserved } : {});
     const created = [];
     const modified = [];
     const removed = [];
@@ -297,7 +299,8 @@ export function runSetup(options) {
         const hooks = ensureHostHooks(root);
         created.push(...hooks.created);
         modified.push(...hooks.modified);
-        const githooks = ensureGitHooks(root);
+        const githooks = ensureGitHooks(root, { forceTrackedReplace: options.forceGitHooks === true });
+        preserved = githooks.preserved;
         created.push(...githooks.created);
         modified.push(...githooks.modified);
         conflicts.push(...githooks.conflicts);
@@ -350,6 +353,7 @@ export function runSetup(options) {
                 modified,
                 removed,
                 conflicts,
+                ...withPreserved(),
                 message: "setup completed with conflicts",
             };
         }
@@ -371,6 +375,7 @@ export function runSetup(options) {
                 modified,
                 removed,
                 conflicts,
+                ...withPreserved(),
                 message: `setup ${operation} completed for ${runtimeVersion} (${RUNTIME_PREFIX}); ${disclosure}`,
             };
         }
@@ -388,6 +393,7 @@ export function runSetup(options) {
             modified,
             removed,
             conflicts,
+            ...withPreserved(),
             message: `setup ${operation} completed for ${runtimeVersion} (${RUNTIME_PREFIX})`,
         };
     }

package/dist/verify-ac.js

@@ -12,7 +12,7 @@ import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveSessionCompletedVerifyAcTarget } from "../vendor/directive-core/dist/check/index.js";
 import { formatRejectedLedger, resolveLiteralAcceptanceDetailed, } from "../vendor/directive-core/dist/literal-acceptance/index.js";
-import { emitVerifyAcTerminalOutcome, evaluateVerifyAcFromPath, readAdmittedSourceDigest, readAdmittedSourceSentences, readPlanAcceptance, resolveAcceptanceGateProfile, resolveSoftMissingAcTargets, } from "../vendor/directive-core/dist/product-first-done-gate/index.js";
+import { emitVerifyAcTerminalOutcome, evaluateVerifyAcFromPath, readAdmittedSourceDigest, readAdmittedSourceSentences, readBranchBindContext, readPlanAcceptance, resolveAcceptanceGateProfile, resolveSoftMissingAcTargets, } from "../vendor/directive-core/dist/product-first-done-gate/index.js";
 /** Parse verify:ac CLI args. */
 export function parseArgs(argv) {
     const parsed = {
@@ -287,11 +287,38 @@ export function run(argv) {
                 }
             }
             else if (args.softMissingXbrief) {
+                const bindContext = readBranchBindContext(projectRoot);
                 const selected = resolveSoftMissingAcTargets(projectRoot, {
                     env: process.env,
                     scannedPaths: found.paths,
+                    branchBind: { ...bindContext, env: process.env },
                 });
-                if (selected.kind === "one") {
+                if (selected.kind === "untied") {
+                    // #5855 P3: completed-target precedence, then soft-missing (no AC claimed).
+                    const completed = resolveSessionCompletedVerifyAcTarget({
+                        projectRoot,
+                        env: process.env,
+                    });
+                    if (completed.kind === "target") {
+                        paths = [completed.path];
+                        if (!args.quiet) {
+                            process.stdout.write(`verify:ac targeting just-completed brief (#3357): ${completed.path}\n`);
+                        }
+                    }
+                    else if (completed.kind === "cannot") {
+                        process.stderr.write(`${completed.message}\n`);
+                        emitVerifyAcTerminalOutcome({ projectRoot, env: process.env, outcome: "config-error" });
+                        return 1;
+                    }
+                    else {
+                        if (!args.quiet) {
+                            process.stdout.write(`${selected.message}\n`);
+                        }
+                        emitVerifyAcTerminalOutcome({ projectRoot, env: process.env, outcome: "soft-missing" });
+                        return 0;
+                    }
+                }
+                else if (selected.kind === "one") {
                     paths = [selected.path];
                     if (!args.quiet) {
                         process.stdout.write(`verify:ac soft-missing multi-active (#4285): selected ${selected.path}\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-runtime",
-  "version": "0.128.0",
+  "version": "0.129.0",
   "description": "Directive runtime — pinned product commands, hooks, content, and engine.",
   "license": "MIT",
   "homepage": "https://deftai.github.io/directive/",