@deftai/directive-runtime 0.129.4 → 0.129.6

package/dist/setup-wiring.js

@@ -9,6 +9,7 @@ import { fileURLToPath } from "node:url";
 import { containedChmod, containedRemove, containedWrite, } from "../vendor/directive-core/dist/fs/contained-write.js";
 import { DIRECT_WRITE_HOOK_MATCHER, KILL_HOOK_MATCHER, MCP_HOOK_MATCHER, SHELL_HOOK_MATCHER, SPAWN_HOOK_MATCHER, } from "../vendor/directive-core/dist/hooks/tools.js";
 import { GROK_PRETOOLUSE_WRAPPER_REL_PATH, HOST_HOOK_MISSING_PIN_PROJECT_PM_GUIDANCE, hostHookOuterCommand, hostHookOuterRelPath, hostHookOuterSha8, hostHookOuterSource, isGrokWrapperCommand, isHostHookOuterCommand, } from "../vendor/directive-core/dist/init-deposit/agent-hooks.js";
+import { DESIRED_GITATTRIBUTES_LINES, ensureGitattributes, LEGACY_CORE_TEXT_EOL_LF, } from "../vendor/directive-core/dist/init-deposit/scaffold.js";
 import { INSTALLATION_RECOVERY_GUIDANCE, RUNTIME_PACKAGE_PATH_PREFIX, } from "../vendor/directive-core/dist/install-health/constants.js";
 import { MANAGED_SECTION_CLOSE, MANAGED_SECTION_OPEN_PREFIX, } from "../vendor/directive-core/dist/install-health/index.js";
 import { applyAgentsRefresh } from "../vendor/directive-core/dist/platform/agents-md.js";
@@ -31,6 +32,25 @@ function readText(path) {
         return null;
     }
 }
+/** Normalize CRLF/CR to LF for ownership/wrapper equality (#5995). */
+export function normalizeEol(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+/** True when two texts differ only by end-of-line convention (#5995). */
+export function contentsEqualIgnoringEol(a, b) {
+    return normalizeEol(a) === normalizeEol(b);
+}
+/**
+ * `.githooks` shell entrypoints must be LF on disk for `sh` (#5995 / PR #6151 P1).
+ * Ownership stays EOL-insensitive; these paths still rewrite CRLF-only drift.
+ */
+export function isShellHookEntrypoint(rel) {
+    const posix = rel.replace(/\\/g, "/");
+    if (!posix.startsWith(".githooks/"))
+        return false;
+    const base = posix.slice(posix.lastIndexOf("/") + 1);
+    return base.endsWith(".sh") || !base.includes(".");
+}
 function writeContained(projectRoot, relPath, body) {
     containedWrite({
         root: projectRoot,
@@ -47,6 +67,11 @@ function trackChange(projectRoot, rel, next) {
     const prior = readText(join(projectRoot, rel));
     if (prior === next)
         return { created: false, modified: false };
+    // CRLF-vs-LF-only diffs are still Directive-managed; skip rewrite for non-shell
+    // paths (#5995). Shell hooks still need LF bytes so `sh` can exec them (#6151 P1).
+    if (prior !== null && contentsEqualIgnoringEol(prior, next) && !isShellHookEntrypoint(rel)) {
+        return { created: false, modified: false };
+    }
     writeContained(projectRoot, rel, next);
     return { created: prior === null, modified: prior !== null };
 }
@@ -227,16 +252,126 @@ function ovprSlashWrapperContents(file) {
  * (legacy .deft/core teaching or package-relative OVPR form).
  */
 function isManagedSlashWrapper(raw, file, next) {
-    if (raw === next)
+    const rawN = normalizeEol(raw);
+    const nextN = normalizeEol(next);
+    if (rawN === nextN)
         return true;
-    if (isThinWrapperMarkdown(raw, file.dispatchPath))
+    if (isThinWrapperMarkdown(rawN, file.dispatchPath))
         return true;
     // Already-rewritten OVPR wrapper: still thin + points at this dispatch path.
-    return (raw.startsWith("---\n") &&
-        raw.includes(file.dispatchPath) &&
-        (raw.includes(RUNTIME_PREFIX) || raw.includes(".deft/core/")) &&
-        raw.includes("Read and follow") &&
-        raw.includes("Do not inline"));
+    return (rawN.startsWith("---\n") &&
+        rawN.includes(file.dispatchPath) &&
+        (rawN.includes(RUNTIME_PREFIX) || rawN.includes(".deft/core/")) &&
+        rawN.includes("Read and follow") &&
+        rawN.includes("Do not inline"));
+}
+/**
+ * True when `rel` has unstaged worktree edits vs the index (#6151 P1).
+ * No repo / no git / clean path → false (safe to report modified for staging).
+ */
+export function pathHasUnstagedChanges(projectRoot, rel) {
+    try {
+        const out = execFileSync("git", ["-C", projectRoot, "diff", "--name-only", "--", rel], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return out.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/** Left-unstaged disclosure when LF pins land on a dirty `.gitattributes` (#6151 P1). */
+export const GITATTRIBUTES_STAGING_SKIPPED_DIRTY = ".gitattributes had unstaged local edits; LF pins were written but left unstaged so install/upgrade does not git add unrelated user changes (#6151 P1)";
+const DESIRED_GITATTRIBUTES_LINE_SET = new Set([
+    ...DESIRED_GITATTRIBUTES_LINES,
+    LEGACY_CORE_TEXT_EOL_LF,
+]);
+/**
+ * True when every attribute line is a known Directive core/managed marker (or
+ * Deft deposit comment). Foreign rules mean the file is not pure Directive-owned
+ * (#6151 P1 dirty-skip heuristic).
+ */
+export function isDirectiveManagedGitattributes(content) {
+    for (const raw of normalizeEol(content).split("\n")) {
+        const line = raw.trim();
+        if (line.length === 0)
+            continue;
+        if (line.startsWith("#")) {
+            if (line.startsWith("# Deft framework:") ||
+                line.startsWith("# Deft managed wiring:") ||
+                line.startsWith("# consumer source.") ||
+                line.startsWith("# byte identity") ||
+                line.startsWith("# to LF so Windows")) {
+                continue;
+            }
+            return false;
+        }
+        if (!DESIRED_GITATTRIBUTES_LINE_SET.has(line))
+            return false;
+    }
+    return true;
+}
+/** True when `rel` exists in the worktree but is not tracked (git repo only). */
+function pathIsUntrackedInRepo(projectRoot, rel) {
+    try {
+        execFileSync("git", ["-C", projectRoot, "rev-parse", "--is-inside-work-tree"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+    }
+    catch {
+        return false;
+    }
+    try {
+        execFileSync("git", ["-C", projectRoot, "ls-files", "--error-unmatch", "--", rel], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return false;
+    }
+    catch {
+        return existsSync(join(projectRoot, rel));
+    }
+}
+/**
+ * Deposit narrow LF .gitattributes for managed wiring paths (#5995).
+ * Reuses scaffold ensureGitattributes (core markers + managed wiring lines).
+ * Reports created/modified so install/upgrade staging commits the pins (#6151 P1).
+ * When the path already has unstaged user edits (or an untracked foreign file),
+ * still appends missing pins but does not report modified (avoids staging WIP).
+ */
+export function ensureManagedPathGitattributes(projectRoot) {
+    const attrsRel = ".gitattributes";
+    const prior = readText(join(projectRoot, attrsRel));
+    // Compute dirty signal before write — post-write `git diff` is true for clean
+    // pin appends too, so it cannot alone decide staging (#6151 P1).
+    const hadUnstagedEdits = prior !== null && pathHasUnstagedChanges(projectRoot, attrsRel);
+    const untrackedForeign = prior !== null &&
+        !isDirectiveManagedGitattributes(prior) &&
+        pathIsUntrackedInRepo(projectRoot, attrsRel);
+    const wrote = ensureGitattributes(projectRoot, { printf: () => undefined });
+    if (!wrote)
+        return { created: false, modified: false, wrote: false };
+    if (prior === null)
+        return { created: true, modified: false, wrote: true };
+    const next = readText(join(projectRoot, attrsRel)) ?? "";
+    // After write: confirm unstaged still, or foreign prior that changed and was
+    // already dirty/untracked — never stage unfinished user WIP with the pins.
+    const stillUnstaged = pathHasUnstagedChanges(projectRoot, attrsRel);
+    const priorForeignChanged = !isDirectiveManagedGitattributes(prior) && !contentsEqualIgnoringEol(prior, next);
+    const treatAsDirty = hadUnstagedEdits ||
+        untrackedForeign ||
+        (stillUnstaged && priorForeignChanged && (hadUnstagedEdits || untrackedForeign));
+    if (treatAsDirty) {
+        return {
+            created: false,
+            modified: false,
+            wrote: true,
+            stagingSkippedNotice: GITATTRIBUTES_STAGING_SKIPPED_DIRTY,
+        };
+    }
+    return { created: false, modified: true, wrote: true };
 }
 /**
  * Deposit host slash/prompt thin wrappers with package-relative targets (AC8.1 / AC8.10).
@@ -244,9 +379,22 @@ function isManagedSlashWrapper(raw, file, next) {
  * Preserves consumer-custom command files and reports conflicts instead of clobbering.
  */
 export function ensureSlashCommands(projectRoot) {
+    // Pin managed wiring paths to LF before compare/deposit (#5995).
+    const attrs = ensureManagedPathGitattributes(projectRoot);
     const created = [];
     const modified = [];
     const conflicts = [];
+    const notices = [];
+    if (attrs.created) {
+        created.push(".gitattributes");
+    }
+    else if (attrs.stagingSkippedNotice) {
+        notices.push(attrs.stagingSkippedNotice);
+        // deliberately omit from modified — dirty user WIP must not be git-added
+    }
+    else if (attrs.modified && attrs.wrote) {
+        modified.push(".gitattributes");
+    }
     const policy = loadHostSlashCommandsPolicyFromProject(projectRoot);
     for (const hostId of listSlashEmitterHosts()) {
         if (!isHostSlashCommandDepositEnabled(hostId, policy))
@@ -255,7 +403,9 @@ export function ensureSlashCommands(projectRoot) {
             const body = ovprSlashWrapperContents(file);
             const next = body.endsWith("\n") ? body : `${body}\n`;
             const prior = readText(join(projectRoot, file.relativePath));
-            if (prior !== null && prior !== next && !isManagedSlashWrapper(prior, file, next)) {
+            if (prior !== null &&
+                !contentsEqualIgnoringEol(prior, next) &&
+                !isManagedSlashWrapper(prior, file, next)) {
                 conflicts.push(`${file.relativePath}: existing command is not a Directive-managed wrapper; refusing to overwrite`);
                 continue;
             }
@@ -266,7 +416,7 @@ export function ensureSlashCommands(projectRoot) {
                 modified.push(file.relativePath);
         }
     }
-    return { created, modified, conflicts };
+    return { created, modified, conflicts, notices };
 }
 /**
  * Verified managed slash/prompt paths from the emitter inventory (AC8.1 / AC11.10).
@@ -692,7 +842,7 @@ export function ensureHostHooks(projectRoot, hostHooksPolicy = loadHostHooksPoli
                 continue;
             const stripped = spec.strip(readJsonObject(abs));
             const next = `${JSON.stringify(stripped, null, 2)}\n`;
-            if (prior === next)
+            if (prior === next || contentsEqualIgnoringEol(prior, next))
                 continue;
             writeContained(projectRoot, spec.rel, next);
             modified.push(spec.rel);
@@ -701,7 +851,7 @@ export function ensureHostHooks(projectRoot, hostHooksPolicy = loadHostHooksPoli
         const base = prior === null ? {} : readJsonObject(abs);
         const merged = spec.merge(base);
         const next = `${JSON.stringify(merged, null, 2)}\n`;
-        if (prior === next)
+        if (prior === next || (prior !== null && contentsEqualIgnoringEol(prior, next)))
             continue;
         writeContained(projectRoot, spec.rel, next);
         if (prior === null)
@@ -717,7 +867,7 @@ export function ensureHostHooks(projectRoot, hostHooksPolicy = loadHostHooksPoli
         const enabled = isHostHookDepositEnabled(host, hostHooksPolicy);
         if (enabled) {
             const prior = readText(join(projectRoot, rel));
-            if (prior !== outerSource) {
+            if (prior === null || !contentsEqualIgnoringEol(prior, outerSource)) {
                 writeContained(projectRoot, rel, outerSource);
                 if (prior === null)
                     created.push(rel);
@@ -855,13 +1005,18 @@ export function ensureGitHooks(projectRoot, options = {}) {
         const rawNext = override ?? file.body;
         const next = rawNext.endsWith("\n") ? rawNext : `${rawNext}\n`;
         const prior = readText(join(projectRoot, file.rel));
-        if (prior !== null && prior !== next && !isOurGitHookBody(file.rel, prior)) {
+        if (prior !== null &&
+            !contentsEqualIgnoringEol(prior, next) &&
+            !isOurGitHookBody(file.rel, prior)) {
             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)) {
+        if (prior !== null &&
+            !contentsEqualIgnoringEol(prior, next) &&
+            !force &&
+            isGitTrackedPath(projectRoot, file.rel)) {
             preserved.push(formatTrackedHookPreserved(file.rel));
             continue;
         }

package/dist/verify-ac.d.ts

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { VERIFY_AC_NO_OBLIGATION_EXIT } from "@deftai/directive-core/product-first-done-gate";
+export { VERIFY_AC_NO_OBLIGATION_EXIT };
 interface ParsedArgs {
     projectRoot: string;
     xbriefPath: string | null;
@@ -20,9 +22,12 @@ export type FindActiveXbriefResult = {
     readonly paths: readonly string[];
     readonly dir: string;
 };
-/** Three-state exit: pass=0, fail=1, config=2. A printed pass must not leak 201. */
+/**
+ * Three-state exit: pass=0, fail=1, config=2, plus deliberate no-obligation=6.
+ * A printed pass must not leak 201. No-obligation is a named clamp exception so
+ * both check dispatch paths keep the distinct exit (#5855 Recut-8).
+ */
 export declare function clampVerifyAcExit(ok: boolean, code: number): number;
 /** Run the gate and return the process exit code. */
 export declare function run(argv: string[]): number;
-export {};
 //# sourceMappingURL=verify-ac.d.ts.map

package/dist/verify-ac.js

@@ -12,7 +12,8 @@ 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, readBranchBindContext, readPlanAcceptance, resolveAcceptanceGateProfile, resolveSoftMissingAcTargets, } from "../vendor/directive-core/dist/product-first-done-gate/index.js";
+import { emitVerifyAcTerminalOutcome, evaluateVerifyAcFromPath, readAdmittedSourceDigest, readAdmittedSourceSentences, readBranchBindContext, readPlanAcceptance, resolveAcceptanceGateProfile, resolveSoftMissingAcTargets, VERIFY_AC_NO_OBLIGATION_EXIT, } from "../vendor/directive-core/dist/product-first-done-gate/index.js";
+export { VERIFY_AC_NO_OBLIGATION_EXIT };
 /** Parse verify:ac CLI args. */
 export function parseArgs(argv) {
     const parsed = {
@@ -104,10 +105,16 @@ function listActiveXbriefs(projectRoot) {
         dir: dirs.join(" + "),
     };
 }
-/** Three-state exit: pass=0, fail=1, config=2. A printed pass must not leak 201. */
+/**
+ * Three-state exit: pass=0, fail=1, config=2, plus deliberate no-obligation=6.
+ * A printed pass must not leak 201. No-obligation is a named clamp exception so
+ * both check dispatch paths keep the distinct exit (#5855 Recut-8).
+ */
 export function clampVerifyAcExit(ok, code) {
     if (ok)
         return 0;
+    if (code === VERIFY_AC_NO_OBLIGATION_EXIT)
+        return VERIFY_AC_NO_OBLIGATION_EXIT;
     if (code === 2)
         return 2;
     return 1;
@@ -291,10 +298,10 @@ export function run(argv) {
                 const selected = resolveSoftMissingAcTargets(projectRoot, {
                     env: process.env,
                     scannedPaths: found.paths,
-                    branchBind: { ...bindContext, env: process.env },
+                    branchBind: { ...bindContext, env: process.env, projectRoot },
                 });
                 if (selected.kind === "untied") {
-                    // #5855 P3: completed-target precedence, then soft-missing (no AC claimed).
+                    // #5855 P3: completed-target precedence, then soft-missing no-obligation.
                     const completed = resolveSessionCompletedVerifyAcTarget({
                         projectRoot,
                         env: process.env,
@@ -315,7 +322,8 @@ export function run(argv) {
                             process.stdout.write(`${selected.message}\n`);
                         }
                         emitVerifyAcTerminalOutcome({ projectRoot, env: process.env, outcome: "soft-missing" });
-                        return 0;
+                        // Distinct non-zero: exit 0 keeps meaning executed AC only (#5855 Recut-8).
+                        return VERIFY_AC_NO_OBLIGATION_EXIT;
                     }
                 }
                 else if (selected.kind === "one") {

package/dist/verify-source-cli/verify-deposit-closure.js

@@ -10,7 +10,7 @@ export function parseArgs(argv) {
         if (arg === "--project-root" || arg === "--pack-root") {
             const value = argv[i + 1];
             if (value === undefined) {
-                return { ...parsed, error: "argument " + arg + ": expected one argument" };
+                return { ...parsed, error: `argument ${arg}: expected one argument` };
             }
             parsed.projectRoot = value;
             parsed.packRootExplicit = arg === "--pack-root";
@@ -24,7 +24,7 @@ export function parseArgs(argv) {
             parsed.packRootExplicit = true;
         }
         else {
-            return { ...parsed, error: "unrecognized argument: " + String(arg) };
+            return { ...parsed, error: `unrecognized argument: ${String(arg)}` };
         }
     }
     return parsed;
@@ -33,16 +33,16 @@ export function parseArgs(argv) {
 export function run(argv) {
     const args = parseArgs(argv);
     if (args.error !== undefined) {
-        process.stderr.write("verify_deposit_closure: " + args.error + "\n");
+        process.stderr.write(`verify_deposit_closure: ${args.error}\n`);
         return 2;
     }
     const root = resolve(args.projectRoot);
     const result = evaluateDepositClosureAtRoot(root, args.packRootExplicit);
     if (result.stream === "stdout") {
-        process.stdout.write(result.message + "\n");
+        process.stdout.write(`${result.message}\n`);
     }
     else {
-        process.stderr.write(result.message + "\n");
+        process.stderr.write(`${result.message}\n`);
     }
     return result.code;
 }

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

@@ -1,5 +1,5 @@
-/** 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"];
+/** Fallback when package.json cannot be read. Keep aligned with launcher bin map (#5997). */
+export declare const PACKAGE_BIN_NAMES: readonly ["directive", "deft", "deft-hook"];
 /** Node owns these shims. This package must not delete them. */
 export declare const NODE_OWNED_SHIM_NAMES: readonly ["npx", "npm"];
 export interface Ps1ShimRemoval {

package/dist/windows-bin-ps1.js

@@ -1,24 +1,18 @@
 /**
  * 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
+ * the bare name never reaches the .cmd. Launcher postinstall runs this 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.
- * Codex deposits bare deft-hook (#4659); this postinstall is what makes Restricted
- * Get-Command select deft-hook.cmd without ExecutionPolicy Bypass.
+ * Codex deposits bare deft-hook (#4659). Launcher postinstall (#5997) runs this
+ * cleanup so Restricted Get-Command selects deft-hook.cmd without Bypass.
  */
 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",
-];
+/** Fallback when package.json cannot be read. Keep aligned with launcher bin map (#5997). */
+export const PACKAGE_BIN_NAMES = ["directive", "deft", "deft-hook"];
 /** Node owns these shims. This package must not delete them. */
 export const NODE_OWNED_SHIM_NAMES = ["npx", "npm"];
 export function packageIsUnderNodeModules(pkgDir) {

package/docs/deft-directive-disable.md

@@ -82,11 +82,11 @@ rm .deft-directive-disable
 # Start a NEW agent session
 ```
 
-## Agent self-serve ban under UAT (#3186)
+## Agent self-serve ban (always-on, grant-gated) (#3186 / #6136)
 
-Operators plant and remove this flag **outside** an agent session (or with a prior human-origin grant). Under **active UAT**, PreToolUse classifies Shell writes that create `.deft-directive-disable` (and permanent opt-out `.no-deft-directive`) as **settings** and **denies** them without a human grant — same posture as `authz:grant` (#3110). Agents must not self-serve the kill-switch to bypass Write / push / PR / merge gates.
+Operators plant and remove this flag **outside** an agent session (or with a prior human-origin grant covering **settings**). PreToolUse **always** denies agent Write / Edit / Shell that creates or renames-to `.deft-directive-disable` (and permanent opt-out `.no-deft-directive`) without that grant — not only under active UAT. Shell write reissue checks the protected basename **before** skipping out-of-tree dests, so a plant outside the repo tree cannot fail-open. Agents must not self-serve the kill-switch to bypass Write / push / PR / merge gates.
 
-Related: `policy:allow-bot-merge`, `policy:allow-direct-commits`, and `policy:disable-directive` (peers) are also settings under UAT and require a human grant.
+Related: `policy:allow-bot-merge`, `policy:allow-direct-commits`, and `policy:disable-directive` (peers) are settings under UAT and require a human grant.
 
 ## Non-goals (v1)
 

package/docs/scope-provenance.md

@@ -73,6 +73,10 @@ When an active implementation brief is **outside** the change set, membership is
 
 Membership-land (Path B activation) PRs that only touch nonterminal `xbrief|vbrief` under `proposed|pending|active` plus optional root `CHANGELOG.md` leave `metadata.productPullRequest` **unset**. Closing-keywords admits that brief-land shape when body has `deft-story: N` covering each changed nonterminal (`isBriefLandShapedDiff` + early return in `evaluateFullStoryMarkAdmission`). Optional `metadata.activationPullRequest` is provenance only — delivery readers ignore it. The stacked product PR stamps virgin `productPullRequest` on the existing null path; leftover keeps the original product stamp. ⊗ Write the activation PR number into `productPullRequest`. Legacy stamped activations unstamp once, then product stamps. Depth: `packages/core/src/pr-closing-keywords/main.ts`.
 
+### Path B activation vs product `verify:ac` (#5792)
+
+Scope-only Path B activation must be able to clear `deft check` before merge-base write authority exists. Check inventories the complete local change set (merge-base..HEAD ∪ dirty ∪ cached ∪ untracked, with rename origins) into `PrDiffPath`, then reuses the Path B witness (`evaluatePathBActivationAdmit`). Inventory base prefers typed `plan.policy.deliveryBranch` / remote default before `master`|`main`, and git-toplevel paths are remapped to `projectRoot` so nested consumers keep brief-land shape. When the inventory is brief-land shaped and the witness admits, check records one named disposition `path_b_activation_deferred` and **defers** product acceptance commands and artifact-clause execution — it does not selectively forgive opaque npm failures and does not bank as a later product verified-pass. Local check without a PR body uses inventory brief issue-ref identity instead of `deft-story` marks; when a PR body is present, mark coverage still applies. Any product path in the inventory, or `productPullRequest` set, restores full `verify:ac`. Write authority stays merge-base-only (`loadStoryWriteFenceFromMergeBase` unchanged). Depth: `packages/core/src/verify-ac/evaluate.ts`, `packages/core/src/check/cached-orchestrator.ts`.
+
 
 ## Historical ship-closeout for stale merged actives (#5403)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-runtime",
-  "version": "0.129.4",
+  "version": "0.129.6",
   "description": "Directive runtime — pinned product commands, hooks, content, and engine.",
   "license": "MIT",
   "homepage": "https://deftai.github.io/directive/",
@@ -82,7 +82,6 @@
     "typescript": "^5.9.3"
   },
   "scripts": {
-    "build": "tsc -b",
-    "postinstall": "node ./scripts/remove-windows-ps1-shims.mjs"
+    "build": "tsc -b"
   }
 }

package/packs/lessons/lessons-pack-0.1.json

@@ -711,6 +711,21 @@
       ],
       "source": "Issue #4888 Prefer-A Bound 6050812821 (parent #964). conflict_group mergeable-state-semantic-policy-invisibility.",
       "body": "**Source:** Issue #4888 Prefer-A Bound 6050812821 (split from parent #964).\n\n**Failure mode:** GitHub `mergeable_state` / `mergeable` report only textual (axis-1) conflicts. After a PR opens, behavioral (CI/test) and policy (`task check` / required contexts) gates can land on the base without a textual conflict. Agents read dirty/clean as readiness or gap-size and miss the invisible policy miss until `task check` runs on the merge result.\n\n**Rule:** Use the three-axis model (textual / behavioral / policy). On conflict-resolve and behind-rebase (PR open; local HEAD matches live remote PR head), require machine-checkable candidate validation keyed to `(pr_head_sha, target_head_sha)` via `evaluateNonCascadeCandidateGreen` / `evaluateSemanticGreen({ requireCandidateValidation: true })`. Attestation is a named allowlisted probe exit 0 (typically pre-pr `task check` / `deft check`); prose stamps are not success. On pre-push, run that local merge-chokepoint gate before push; require the SHA-pair attestation only after push when local HEAD matches the live remote PR head. Do not weaken `--cascade` absolute stale-base refusal. Keep #4889 out; do not satisfy with a withdrawn Python semantic-drift script SoT. Forge supersession is #633/#1517 required Merge gate aggregator + up-to-date-required; local probe is interim.\n\n**Canonical encoding (strongest-applicable layer):** probe in `packages/core/src/pr-wait-mergeable/semantic-green.ts` (`requireCandidateValidation` / `validateCandidateAttestation`); operative MUST in `content/scm/github.md` § Cascade / Three-axis (#4888) and `skills/deft-directive-pre-pr/SKILL.md` merge-chokepoint attach; forge supersession in `content/scm/github.md` § Merge-gate aggregator (#633). AGENTS/agents-entry pointer only.\n\n**Cross-references:** #4888, #964, #2385, #1369, #633, #1517, #4883 (CLEAN = axis-1 necessity), #4889 (kept out)."
+    },
+    {
+      "id": "edit-files-search-strings-must-capture-full-units-not-substrings-2026-05",
+      "title": "edit_files search strings MUST capture full units, not substrings (2026-05)",
+      "date": "2026-05",
+      "issue_refs": [
+        "#1037"
+      ],
+      "tags": [
+        "debugging",
+        "agent-orchestration",
+        "github"
+      ],
+      "source": "Issue #1037 Prefer-A Bound 6689115138. Recurrence: PR #1034 (2026-05-11); #911 cascade (2026-05-04).",
+      "body": "**Source:** Issue #1037 Prefer-A Bound 6689115138. Recurrence: PR #1034 (2026-05-11) Greptile P1 on truncated CHANGELOG #441 close-out bullet; sibling outcome class in the #911 cascade (2026-05-04).\n\n**Failure mode:** Exact-string replace tools (`edit_files` / StrReplace-class) replace only the matched `search` bytes. When the agent anchors on a substring of a longer single-line or multi-line entry (CHANGELOG bullet, ROADMAP list item, section body), the unmatched overflow past the search anchor is deleted with the match. The tool did what it was asked; the agent chose too short a search.\n\n**Rule:** When using exact-string-match replacement to modify a single-line or multi-line entry, the `search` value MUST match the FULL line / FULL entry being targeted, including any trailing prose / continuation the agent intends to preserve.\n\n**Anti-pattern:** Pick the first N words of a long bullet as the search anchor; the replacement silently truncates the bullet at the end of the matched substring.\n\n**Mitigation:**\n- ! When targeting a markdown bullet, the `search` value MUST extend to the next blank line or the next top-level list marker, whichever comes first. Re-read the file and capture ALL bytes that belong to the targeted entry.\n- ! When adding a new bullet ABOVE an existing one, an even safer pattern is to anchor `search` on the section heading (e.g. `### Refinement`) and re-emit the heading in `replace` followed by the new bullet and the existing first bullet -- but you MUST still capture every byte of that existing first bullet.\n- ! After every exact-string replace that touches CHANGELOG.md, ROADMAP.md, or any other append-only narrative file, re-read the surrounding 20 lines of the edited region and verify nothing was truncated. This is part of the standard pre-commit file review.\n\n**Recurrence record:**\n- PR #1034 (2026-05-11) -- CHANGELOG.md `### Refinement` first bullet truncated when adding a new bullet above it; Greptile caught it as a P1 in review-cycle.\n- PR #911 cascade (2026-05-04) -- different mechanism (HEAD-only slice resolution), same outcome class: CHANGELOG `[Unreleased]` branch entries dropped on conflict resolution.\n\n**Canonical encoding:** lessons-pack-0.1 entry (this body); projected via `task packs:render` into `meta/lessons.md`. Lesson-tier only -- no new AGENTS.md always-pin; optional `verify:changelog-bullets` stays out of Bound (#1037 Prefer-A Reject).\n\n**Cross-references:** Issue #1037, Prefer-A Bound 6689115138, PR #1034, PR #911 cascade, `skills/deft-directive-build/SKILL.md` / `skills/deft-directive-refinement/SKILL.md` pre-commit file review."
     }
   ]
 }