@deftai/directive-core 0.77.0 → 0.79.0

package/dist/hooks/scope.js

@@ -0,0 +1,46 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+import { hasArtifactSuffix } from "../layout/resolve.js";
+import { evaluate } from "../preflight/evaluate.js";
+/**
+ * Find an implementation-eligible scope by delegating every candidate to the
+ * existing xBRIEF preflight evaluator. This intentionally creates no second
+ * lifecycle/status policy stack.
+ */
+export function inspectActiveScope(projectRoot) {
+    const candidates = [];
+    for (const relativeDir of [join("xbrief", "active"), join("vbrief", "active")]) {
+        const activeDir = join(projectRoot, relativeDir);
+        try {
+            for (const entry of readdirSync(activeDir, { withFileTypes: true })) {
+                if (entry.isFile() && hasArtifactSuffix(entry.name)) {
+                    candidates.push(join(activeDir, entry.name));
+                }
+            }
+        }
+        catch {
+            // A missing/unreadable active folder contributes no eligible candidate.
+        }
+    }
+    // Stable traversal makes the selected path and first rejection reproducible.
+    // This is not a priority rule: every candidate is evaluated until one passes.
+    candidates.sort();
+    let firstRejection = null;
+    for (const candidate of candidates) {
+        const result = evaluate(candidate);
+        if (result.exitCode === 0) {
+            return { ready: true, path: candidate, message: result.message };
+        }
+        firstRejection ??= result.message;
+    }
+    if (firstRejection !== null) {
+        return { ready: false, path: null, message: firstRejection };
+    }
+    return {
+        ready: false,
+        path: null,
+        message: "No active xBRIEF artifact was found under xbrief/active/ " +
+            "(or the legacy vbrief/active/ compatibility path).",
+    };
+}
+//# sourceMappingURL=scope.js.map

package/dist/hooks/tools.d.ts

@@ -0,0 +1,4 @@
+/** Host spellings that install-time matchers and runtime classification share. */
+export declare const DIRECT_WRITE_TOOL_NAMES: readonly ["Edit", "Write", "WriteFile", "CreateFile", "MultiEdit", "NotebookEdit", "StrReplace", "SearchReplace", "Delete", "DeleteFile", "ApplyPatch", "apply_patch"];
+export declare function isDirectWriteTool(toolName: string): boolean;
+//# sourceMappingURL=tools.d.ts.map

package/dist/hooks/tools.js

@@ -0,0 +1,23 @@
+/** Host spellings that install-time matchers and runtime classification share. */
+export const DIRECT_WRITE_TOOL_NAMES = [
+    "Edit",
+    "Write",
+    "WriteFile",
+    "CreateFile",
+    "MultiEdit",
+    "NotebookEdit",
+    "StrReplace",
+    "SearchReplace",
+    "Delete",
+    "DeleteFile",
+    "ApplyPatch",
+    "apply_patch",
+];
+function normalizedToolName(toolName) {
+    return toolName.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+const DIRECT_WRITE_TOOLS = new Set(DIRECT_WRITE_TOOL_NAMES.map(normalizedToolName));
+export function isDirectWriteTool(toolName) {
+    return DIRECT_WRITE_TOOLS.has(normalizedToolName(toolName));
+}
+//# sourceMappingURL=tools.js.map

package/dist/init-deposit/agent-hooks.d.ts

@@ -0,0 +1,22 @@
+import type { HookHost } from "../hooks/dispatcher.js";
+import type { InitDepositIo } from "./constants.js";
+export declare const DIRECT_WRITE_HOOK_MATCHER: string;
+export declare const DEFT_HOOK_COMMAND_MARKER = "deft hook:dispatch";
+export declare const AGENT_HOOK_PATHS: readonly [".claude/settings.json", ".grok/hooks/deft.json", ".cursor/hooks.json", ".codex/hooks.json"];
+export type AgentHookPath = (typeof AGENT_HOOK_PATHS)[number];
+export type AgentHookRegistrationStatus = "healthy" | "missing" | "drifted";
+export interface AgentHookInspection {
+    readonly host: HookHost;
+    readonly path: AgentHookPath;
+    readonly status: AgentHookRegistrationStatus;
+    readonly detail: string;
+}
+export interface AgentHookDepositResult {
+    readonly changed: boolean;
+    readonly changedPaths: AgentHookPath[];
+}
+/** Merge Directive-owned project hook entries without replacing user configuration. */
+export declare function writeAgentHookDeposit(projectRoot: string, io?: InitDepositIo): AgentHookDepositResult;
+/** Read-only registration probe shared by verify and doctor. */
+export declare function inspectAgentHookDeposit(projectRoot: string): AgentHookInspection[];
+//# sourceMappingURL=agent-hooks.d.ts.map

package/dist/init-deposit/agent-hooks.js

@@ -0,0 +1,238 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { assertDepositContained } from "../deposit/contain.js";
+import { DIRECT_WRITE_TOOL_NAMES } from "../hooks/tools.js";
+export const DIRECT_WRITE_HOOK_MATCHER = DIRECT_WRITE_TOOL_NAMES.join("|");
+export const DEFT_HOOK_COMMAND_MARKER = "deft hook:dispatch";
+export const AGENT_HOOK_PATHS = [
+    ".claude/settings.json",
+    ".grok/hooks/deft.json",
+    ".cursor/hooks.json",
+    ".codex/hooks.json",
+];
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function command(host, event) {
+    return `${DEFT_HOOK_COMMAND_MARKER} --host ${host} --event ${event}`;
+}
+function readConfig(path) {
+    if (!existsSync(path))
+        return {};
+    const raw = readFileSync(path, "utf8");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (cause) {
+        throw new Error(`${path} is not valid JSON; refusing to overwrite user configuration: ${cause}`);
+    }
+    const config = object(parsed);
+    if (config === null) {
+        throw new Error(`${path} must contain a JSON object; refusing to overwrite user configuration.`);
+    }
+    return config;
+}
+function hooksObject(config, path) {
+    if (config.hooks === undefined)
+        return {};
+    const hooks = object(config.hooks);
+    if (hooks === null)
+        throw new Error(`${path}: hooks must be a JSON object.`);
+    return { ...hooks };
+}
+function eventArray(hooks, key, path) {
+    const value = hooks[key];
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new Error(`${path}: hooks.${key} must be an array.`);
+    return [...value];
+}
+function nestedCommands(value) {
+    const group = object(value);
+    if (group === null || !Array.isArray(group.hooks))
+        return [];
+    return group.hooks.flatMap((candidate) => {
+        const hook = object(candidate);
+        return typeof hook?.command === "string" ? [hook.command] : [];
+    });
+}
+function isManagedNestedGroup(value) {
+    return nestedCommands(value).some((value) => value.includes(DEFT_HOOK_COMMAND_MARKER));
+}
+function isManagedCursorEntry(value) {
+    const entry = object(value);
+    return typeof entry?.command === "string" && entry.command.includes(DEFT_HOOK_COMMAND_MARKER);
+}
+function nestedGroup(host, event) {
+    return {
+        ...(event === "tool.before" ? { matcher: DIRECT_WRITE_HOOK_MATCHER } : {}),
+        hooks: [
+            {
+                type: "command",
+                command: command(host, event),
+                timeout: 5,
+            },
+        ],
+    };
+}
+function mergeNestedConfig(config, path, host) {
+    const hooks = hooksObject(config, path);
+    const session = eventArray(hooks, "SessionStart", path).filter((entry) => !isManagedNestedGroup(entry));
+    const preTool = eventArray(hooks, "PreToolUse", path).filter((entry) => !isManagedNestedGroup(entry));
+    hooks.SessionStart = [...session, nestedGroup(host, "session.start")];
+    hooks.PreToolUse = [...preTool, nestedGroup(host, "tool.before")];
+    return { ...config, hooks };
+}
+function mergeCursorConfig(config, path) {
+    const hooks = hooksObject(config, path);
+    const session = eventArray(hooks, "sessionStart", path).filter((entry) => !isManagedCursorEntry(entry));
+    const preTool = eventArray(hooks, "preToolUse", path).filter((entry) => !isManagedCursorEntry(entry));
+    hooks.sessionStart = [...session, { command: command("cursor", "session.start"), timeout: 5 }];
+    hooks.preToolUse = [
+        ...preTool,
+        {
+            command: command("cursor", "tool.before"),
+            matcher: DIRECT_WRITE_HOOK_MATCHER,
+            failClosed: true,
+            timeout: 5,
+        },
+    ];
+    return { ...config, version: 1, hooks };
+}
+function writeJsonIfChanged(path, payload) {
+    const next = `${JSON.stringify(payload, null, 2)}\n`;
+    if (existsSync(path) && readFileSync(path, "utf8") === next)
+        return false;
+    mkdirSync(dirname(path), { recursive: true });
+    const temporary = `${path}.deft-${process.pid}.tmp`;
+    writeFileSync(temporary, next, "utf8");
+    renameSync(temporary, path);
+    return true;
+}
+/** Merge Directive-owned project hook entries without replacing user configuration. */
+export function writeAgentHookDeposit(projectRoot, io = { printf: () => undefined }) {
+    const changedPaths = [];
+    const definitions = [
+        {
+            path: AGENT_HOOK_PATHS[0],
+            merge: (config, path) => mergeNestedConfig(config, path, "claude"),
+        },
+        {
+            path: AGENT_HOOK_PATHS[1],
+            merge: (config, path) => mergeNestedConfig(config, path, "grok"),
+        },
+        { path: AGENT_HOOK_PATHS[2], merge: mergeCursorConfig },
+        {
+            path: AGENT_HOOK_PATHS[3],
+            merge: (config, path) => mergeNestedConfig(config, path, "codex"),
+        },
+    ];
+    const prepared = definitions.map((definition) => {
+        const absolute = join(projectRoot, definition.path);
+        assertDepositContained(projectRoot, absolute);
+        const merged = definition.merge(readConfig(absolute), absolute);
+        return { ...definition, absolute, merged };
+    });
+    for (const definition of prepared) {
+        if (writeJsonIfChanged(definition.absolute, definition.merged)) {
+            changedPaths.push(definition.path);
+        }
+    }
+    if (changedPaths.length > 0) {
+        io.printf(`Installed Directive agent hooks: ${changedPaths.join(", ")}\n`);
+    }
+    else {
+        io.printf("Directive agent hooks already current.\n");
+    }
+    return { changed: changedPaths.length > 0, changedPaths };
+}
+function hasNestedRegistration(config, host) {
+    const hooks = object(config.hooks);
+    if (hooks === null)
+        return false;
+    const session = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+    const preTool = Array.isArray(hooks.PreToolUse) ? hooks.PreToolUse : [];
+    const sessionCommand = command(host, "session.start");
+    const toolCommand = command(host, "tool.before");
+    return (session.some((entry) => nestedCommands(entry).includes(sessionCommand)) &&
+        preTool.some((entry) => {
+            const group = object(entry);
+            return (group?.matcher === DIRECT_WRITE_HOOK_MATCHER && nestedCommands(entry).includes(toolCommand));
+        }));
+}
+function hasCursorRegistration(config) {
+    const hooks = object(config.hooks);
+    if (hooks === null || config.version !== 1)
+        return false;
+    const session = Array.isArray(hooks.sessionStart) ? hooks.sessionStart : [];
+    const preTool = Array.isArray(hooks.preToolUse) ? hooks.preToolUse : [];
+    return (session.some((entry) => object(entry)?.command === command("cursor", "session.start")) &&
+        preTool.some((entry) => {
+            const hook = object(entry);
+            return (hook?.command === command("cursor", "tool.before") &&
+                hook.matcher === DIRECT_WRITE_HOOK_MATCHER &&
+                hook.failClosed === true);
+        }));
+}
+/** Read-only registration probe shared by verify and doctor. */
+export function inspectAgentHookDeposit(projectRoot) {
+    const definitions = [
+        {
+            host: "claude",
+            path: AGENT_HOOK_PATHS[0],
+            valid: (config) => hasNestedRegistration(config, "claude"),
+        },
+        {
+            host: "grok",
+            path: AGENT_HOOK_PATHS[1],
+            valid: (config) => hasNestedRegistration(config, "grok"),
+        },
+        { host: "cursor", path: AGENT_HOOK_PATHS[2], valid: hasCursorRegistration },
+        {
+            host: "codex",
+            path: AGENT_HOOK_PATHS[3],
+            valid: (config) => hasNestedRegistration(config, "codex"),
+        },
+    ];
+    return definitions.map((definition) => {
+        const absolute = join(projectRoot, definition.path);
+        if (!existsSync(absolute)) {
+            return {
+                host: definition.host,
+                path: definition.path,
+                status: "missing",
+                detail: `${definition.path} is missing.`,
+            };
+        }
+        try {
+            const config = readConfig(absolute);
+            if (definition.valid(config)) {
+                return {
+                    host: definition.host,
+                    path: definition.path,
+                    status: "healthy",
+                    detail: "SessionStart and direct-write PreToolUse registrations are current.",
+                };
+            }
+            return {
+                host: definition.host,
+                path: definition.path,
+                status: "drifted",
+                detail: "Directive SessionStart or direct-write PreToolUse registration is missing/drifted.",
+            };
+        }
+        catch (cause) {
+            return {
+                host: definition.host,
+                path: definition.path,
+                status: "drifted",
+                detail: String(cause),
+            };
+        }
+    });
+}
+//# sourceMappingURL=agent-hooks.js.map

package/dist/init-deposit/hygiene.js

@@ -21,6 +21,10 @@ export function installerManagedMatchers() {
         { exact: "AGENTS.md" },
         { prefix: ".agents/" },
         { prefix: ".githooks/" },
+        { exact: ".claude/settings.json" },
+        { exact: ".grok/hooks/deft.json" },
+        { exact: ".cursor/hooks.json" },
+        { exact: ".codex/hooks.json" },
         { exact: ".gitattributes" },
         { exact: ".gitignore" },
         { exact: "greptile.json" },

package/dist/init-deposit/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./agent-hooks.js";
 export * from "./headless-manifest.js";
 export * from "./init-deposit.js";
 export * from "./init-dispatch.js";

package/dist/init-deposit/index.js

@@ -1,3 +1,4 @@
+export * from "./agent-hooks.js";
 export * from "./headless-manifest.js";
 export * from "./init-deposit.js";
 export * from "./init-dispatch.js";

package/dist/init-deposit/init-deposit.js

@@ -13,10 +13,12 @@ import { copyTree } from "../deposit/copy-tree.js";
 import { prunePythonArtifactsFromDeposit } from "../deposit/python-free.js";
 import { resolveInstalledContentRoot } from "../deposit/resolve-content.js";
 import { readCorePackageVersion } from "../engine-version.js";
+import { writeAgentHookDeposit } from "./agent-hooks.js";
 import { ensureInitGitignoreLines, reconstituteDepositFromContent } from "./gitignore.js";
 import { depositStagePaths, printCommitGuidance } from "./hygiene.js";
 import { buildLegacyRefusalJson, buildLegacyRefusalMessage, detectLegacyLayout, LEGACY_LAYOUT_REFUSED_EXIT_CODE, LegacyLayoutRefusedError, } from "./legacy-detect.js";
 import { printMigrateNudgeIfNeeded } from "./migrate.js";
+import { ensurePrettierIgnoreLines } from "./prettierignore.js";
 import { CANONICAL_INSTALL_ROOT, depositNeutralization, ensureTaskfile, writeAgentsMd, writeAgentsSkills, writeConsumerGitHooks, writeConsumerVbrief, writeInstallManifest, } from "./scaffold.js";
 export function parseInitArgv(canonicalArgv, userArgv = []) {
     const args = [...canonicalArgv, ...userArgv];
@@ -136,6 +138,7 @@ export async function runInitDeposit(args, io, seams = {}) {
     await reconstituteDepositFromContent(contentRoot, deftDir, copyContent);
     await prunePythonArtifactsFromDeposit(deftDir, projectDir, io);
     ensureInitGitignoreLines(projectDir, io);
+    ensurePrettierIgnoreLines(projectDir, io);
     const nowIso = seams.nowIso ?? (() => new Date().toISOString().replace(/\.\d{3}Z$/, "Z"));
     const version = readContentVersion(contentRoot, seams.readPackageVersion ?? readCorePackageVersion);
     const manifestFields = {
@@ -152,6 +155,7 @@ export async function runInitDeposit(args, io, seams = {}) {
     await depositNeutralization(projectDir, io);
     await writeConsumerVbrief(projectDir, deftDir, io);
     writeConsumerGitHooks(projectDir, deftDir, io, seams.gitHooks);
+    writeAgentHookDeposit(projectDir, io);
     let taskfileWired = false;
     if (args.nonInteractive) {
         taskfileWired = ensureTaskfile(projectDir, io);

package/dist/init-deposit/prettierignore.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Consumer `.prettierignore` upkeep for install and npm-managed update (#2534).
+ *
+ * Managed `.deft/core/` is outside the consumer Prettier format gate. Official
+ * install and `directive update` heal the ignore entry idempotently without
+ * reformatting the vendored deposit.
+ *
+ * Refs #2534, #670.
+ */
+import type { InitDepositIo } from "./constants.js";
+/** Directory ignore entry for the hybrid deposit. */
+export declare const PRETTIERIGNORE_DEFT_CORE_LINE = ".deft/core/";
+export interface EnsurePrettierIgnoreResult {
+    readonly changed: boolean;
+}
+/**
+ * Ensure the consumer `.prettierignore` excludes managed `.deft/core/` from
+ * Prettier. Idempotent; preserves consumer preamble.
+ */
+export declare function ensurePrettierIgnoreLines(projectDir: string, io: InitDepositIo): EnsurePrettierIgnoreResult;
+//# sourceMappingURL=prettierignore.d.ts.map

package/dist/init-deposit/prettierignore.js

@@ -0,0 +1,83 @@
+/**
+ * Consumer `.prettierignore` upkeep for install and npm-managed update (#2534).
+ *
+ * Managed `.deft/core/` is outside the consumer Prettier format gate. Official
+ * install and `directive update` heal the ignore entry idempotently without
+ * reformatting the vendored deposit.
+ *
+ * Refs #2534, #670.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { assertProjectionContained } from "../fs/projection-containment.js";
+import { stripGitignoreInlineComment } from "../triage/bootstrap/gitignore.js";
+/** Directory ignore entry for the hybrid deposit. */
+export const PRETTIERIGNORE_DEFT_CORE_LINE = ".deft/core/";
+/** Alternate spellings that already cover the deposit ignore entry. */
+const DEFT_CORE_COVERING_LINES = new Set([".deft/core/", ".deft/core", ".deft/core/**"]);
+const DEFT_FRAMEWORK_PRETTIERIGNORE_HEADER = "# Deft framework: the vendored payload is outside the consumer Prettier gate (#2534).\n";
+function projectionTarget(projectDir) {
+    const target = join(projectDir, ".prettierignore");
+    assertProjectionContained(projectDir, target);
+    return target;
+}
+function prettierIgnoreCoversLine(present, line) {
+    if (present.has(line))
+        return true;
+    if (line === PRETTIERIGNORE_DEFT_CORE_LINE) {
+        return [...DEFT_CORE_COVERING_LINES].some((candidate) => present.has(candidate));
+    }
+    return false;
+}
+function collectPresentPrettierIgnoreLines(existing) {
+    const present = new Set();
+    for (const raw of existing.split("\n")) {
+        const stripped = stripGitignoreInlineComment(raw);
+        if (stripped)
+            present.add(stripped);
+    }
+    return present;
+}
+/**
+ * Ensure the consumer `.prettierignore` excludes managed `.deft/core/` from
+ * Prettier. Idempotent; preserves consumer preamble.
+ */
+export function ensurePrettierIgnoreLines(projectDir, io) {
+    const path = projectionTarget(projectDir);
+    let existing = "";
+    if (existsSync(path)) {
+        try {
+            existing = readFileSync(path, { encoding: "utf8" });
+        }
+        catch (cause) {
+            throw new Error(`could not read .prettierignore: ${String(cause)}`);
+        }
+    }
+    const present = collectPresentPrettierIgnoreLines(existing);
+    const targetLines = [PRETTIERIGNORE_DEFT_CORE_LINE];
+    const additions = targetLines.filter((line) => !prettierIgnoreCoversLine(present, line));
+    if (additions.length === 0) {
+        io.printf(".prettierignore already excludes the managed deft framework deposit — skipping.\n");
+        return { changed: false };
+    }
+    let body = existing;
+    if (body !== "" && !body.endsWith("\n")) {
+        body += "\n";
+    }
+    if (body !== "" && !body.endsWith("\n\n")) {
+        body += "\n";
+    }
+    body += DEFT_FRAMEWORK_PRETTIERIGNORE_HEADER;
+    for (const add of additions) {
+        body += `${add}\n`;
+    }
+    try {
+        writeFileSync(path, body, { encoding: "utf8", mode: 0o644 });
+    }
+    catch (cause) {
+        throw new Error(`could not write .prettierignore: ${String(cause)}`);
+    }
+    io.printf(`.prettierignore updated with Deft framework exclusions: ${additions.join(", ")}\n`);
+    return { changed: true };
+}
+//# sourceMappingURL=prettierignore.js.map

package/dist/init-deposit/refresh.d.ts

@@ -12,7 +12,7 @@ import { type ClassifySeams, type EngineInstallRunner, type EngineResolution, ty
 import { type GitLsFiles } from "./gitignore.js";
 import { type InitDepositArgs } from "./init-deposit.js";
 import { type LegacyLayoutDetection } from "./legacy-detect.js";
-import { type InitDepositIo } from "./scaffold.js";
+import { type GitHooksSeams, type InitDepositIo } from "./scaffold.js";
 export interface RefreshDepositArgs extends InitDepositArgs {
     readonly upgrade: boolean;
 }
@@ -45,6 +45,8 @@ export interface RefreshDepositSeams {
      * upkeep so the refresh never invokes a destructive `git rm --cached` path.
      */
     gitLsFiles?: GitLsFiles;
+    /** #2530: injected git config seams for {@link writeConsumerGitHooks}. */
+    gitHooks?: GitHooksSeams;
 }
 /**
  * The four states `directive update` classifies an EXISTING install into BEFORE

package/dist/init-deposit/refresh.js

@@ -8,7 +8,7 @@
  * Refs #1942, #1430, #1671.
  */
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, renameSync, statSync } from "node:fs";
 import { platform as osPlatform } from "node:os";
 import { join, resolve } from "node:path";
 import { assertDepositContained } from "../deposit/contain.js";
@@ -18,15 +18,26 @@ import { resolveInstalledContentRoot } from "../deposit/resolve-content.js";
 import { manifestTagToVersion, parseInstallManifest } from "../doctor/manifest.js";
 import { readCorePackageVersion } from "../engine-version.js";
 import { resolveLifecycleRoot } from "../layout/resolve.js";
-import { DEV_FALLBACK } from "../platform/constants.js";
 import { checkLocalEngineIntegrity, classify, ENGINE_PACKAGE, plan, renderGlobalInstall, resolveEngine, } from "../resolution/index.js";
 import { gitPorcelain } from "../story-ready/git.js";
+import { writeAgentHookDeposit } from "./agent-hooks.js";
 import { ensureInitGitignoreLines, isDepositTrackedInGit } from "./gitignore.js";
 import { depositStagePaths, isInstallerManagedPath, printCommitGuidance, pruneStrayDepositPaths, } from "./hygiene.js";
 import { parseInitArgv } from "./init-deposit.js";
 import { buildLegacyRefusalJson, buildLegacyRefusalMessage, detectLegacyLayout, LEGACY_LAYOUT_REFUSED_EXIT_CODE, LegacyLayoutRefusedError, } from "./legacy-detect.js";
 import { printMigrateNudgeIfNeeded } from "./migrate.js";
-import { CANONICAL_INSTALL_ROOT, depositNeutralization, ensureTaskfile, writeAgentsMd, writeInstallManifest, } from "./scaffold.js";
+import { ensurePrettierIgnoreLines } from "./prettierignore.js";
+import { CANONICAL_INSTALL_ROOT, depositNeutralization, ensureTaskfile, writeAgentsMd, writeConsumerGitHooks, writeInstallManifest, } from "./scaffold.js";
+import { syncBareVersionMarker, syncConsumerXbriefSchemas, syncExistingBareVersionMarker, } from "./xbrief-projections.js";
+function hasCanonicalXbriefLifecycle(projectDir) {
+    try {
+        resolveLifecycleRoot(projectDir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /** The exact refusal shown when `update` runs against an un-initialized project. */
 export const NOT_INITIALIZED_MESSAGE = "This project is not initialized. Run directive init.";
 /** `update` refused because the project has no install / needs a different verb. */
@@ -146,39 +157,6 @@ function readRecordedManagedBy(deftDir) {
         return null;
     }
 }
-/**
- * Regenerate the bare `.deft-version` derivative from the deposited content
- * version in the same transaction as the payload swap (#2055). The canonical
- * marker lives at `vbrief/.deft-version`; fall back to the project root only
- * when `vbrief/` is absent. Never persist the dev fallback.
- */
-function syncBareVersionMarker(projectDir, version) {
-    const normalized = normalizeVersion(version);
-    if (!normalized || normalized === DEV_FALLBACK)
-        return;
-    let vbriefDir = null;
-    try {
-        vbriefDir = resolveLifecycleRoot(projectDir);
-    }
-    catch {
-        // No xbrief/ layout present — write the root-level derivative instead.
-    }
-    let targetDir = projectDir;
-    try {
-        if (vbriefDir !== null && statSync(vbriefDir).isDirectory())
-            targetDir = vbriefDir;
-    }
-    catch {
-        // xbrief/ absent — write the root-level derivative instead
-    }
-    try {
-        mkdirSync(targetDir, { recursive: true });
-        writeFileSync(join(targetDir, ".deft-version"), `${normalized}\n`, "utf8");
-    }
-    catch {
-        // best-effort, mirrors install-upgrade marker write
-    }
-}
 /**
  * Retire a stale legacy `.deft/VERSION` after the canonical `.deft/core/VERSION`
  * has been (re)written (#2064). Folded in from the former `install-upgrade`
@@ -450,13 +428,25 @@ export async function runRefreshDeposit(args, io, seams = {}) {
         // .deft/core/VERSION has been rewritten (folded in from install-upgrade so no
         // manifest behavior is lost by the redirect). Best-effort; never fatal.
         migrateLegacyInstallManifest(projectDir, writtenManifestPath);
-        // #2055: regenerate the bare .deft-version derivative so it agrees with the
-        // freshly written manifest tag (otherwise doctor's manifest-agreement check
-        // fails and the operator must hand-edit the marker). No-op refreshes skip
-        // this projection because the manifest tag was not rewritten (#2118).
+    }
+    // #2595: payload freshness and consumer derivative freshness are independent.
+    // Always repair these cheap projections, including on the #2118 no-op path.
+    if (alreadyCurrent) {
+        syncExistingBareVersionMarker(projectDir, contentVersion);
+    }
+    else {
         syncBareVersionMarker(projectDir, contentVersion);
     }
+    // Do not turn a legacy-only or cache-only support tree into canonical
+    // lifecycle content before migrate:xbrief can transactionally converge it.
+    if (hasCanonicalXbriefLifecycle(projectDir)) {
+        syncConsumerXbriefSchemas(projectDir, deftDir);
+    }
     const agentsMdUpdated = writeAgentsMd(projectDir, deftDir, io);
+    writeAgentHookDeposit(projectDir, io);
+    // #2530: root `.githooks/` is a consumer derivative like #2595 marker/schemas —
+    // repair on every refresh, including the already-current no-op path.
+    writeConsumerGitHooks(projectDir, deftDir, io, seams.gitHooks);
     // #2148: the deft-core-guard CI workflow is only meaningful when the deposit
     // is git-tracked (committed vendor layout). On an npm-managed (gitignored)
     // deposit it creates untracked noise after every `directive update`. Probe
@@ -470,6 +460,7 @@ export async function runRefreshDeposit(args, io, seams = {}) {
     // destructive `git rm --cached .deft/core` un-track is the deliberate
     // `migrate --untrack-core` step (#2269), not `update`.
     ensureInitGitignoreLines(projectDir, io, { gitLsFiles: seams.gitLsFiles });
+    ensurePrettierIgnoreLines(projectDir, io);
     let taskfileWired = false;
     if (args.nonInteractive) {
         taskfileWired = ensureTaskfile(projectDir, io);