@deftai/directive-core 0.84.0 → 0.86.0

package/dist/doctor/types.d.ts

@@ -4,6 +4,7 @@ import type { EngineProbeResult } from "../resolution/classify.js";
 import type { ResolutionMode } from "../resolution/index.js";
 import type { ResolveUserMdResult } from "../user-config/resolve-user-md.js";
 import type { AgentHookHealthResult } from "../verify-env/agent-hooks.js";
+import type { AgentHookLiveProbeResult } from "../verify-env/agent-hooks-live-probe.js";
 export declare const EXIT_CLEAN = 0;
 export declare const EXIT_DRIFT = 1;
 export declare const EXIT_CONFIG_ERROR = 2;
@@ -30,6 +31,13 @@ export interface Finding {
     readonly status?: string;
     readonly [key: string]: unknown;
 }
+/** Result of an offline `npm config get` query. */
+export interface NpmConfigGetResult {
+    readonly ok: boolean;
+    readonly value: string;
+}
+/** Injectable npm-config reader used by doctor and its throttle-safe signposts. */
+export type NpmConfigGet = (key: string, cwd: string) => NpmConfigGetResult;
 /**
  * The single read-only decision surface derived from the shared keystone
  * `plan()` (#2267 / epic #2203). `plan()` is the ONE classifier: doctor never
@@ -99,6 +107,8 @@ export interface DoctorSeams {
         ok: boolean;
         version: string;
     };
+    /** Offline npm configuration reader for effective-registry diagnostics (#2808). */
+    readonly runNpmConfigGet?: NpmConfigGet;
     readonly agentsRefreshPlan?: (projectRoot: string) => Record<string, unknown>;
     readonly agentsMdAdvisoryEvaluate?: (projectRoot: string) => AdvisoryEvaluateResult;
     readonly readState?: (projectRoot: string) => DoctorState | null;
@@ -138,5 +148,7 @@ export interface DoctorSeams {
     readonly detectPlanExtensionShadows?: (projectRoot: string) => readonly ShadowedPlanExtension[];
     /** Read-only agent-host hook registration probe (#2438). */
     readonly evaluateAgentHooks?: (projectRoot: string) => AgentHookHealthResult;
+    /** Live hook spawn probe for doctor --full (#2852). */
+    readonly probeAgentHooksLive?: (projectRoot: string) => AgentHookLiveProbeResult;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/eval-health-relocation/evaluate.js

@@ -2,6 +2,7 @@ import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { evaluateHealth } from "../eval/health.js";
+import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 import { resolveEvalPath } from "../layout/resolve.js";
 import { matchAny } from "../orchestration/pathspec.js";
 /** Glob patterns that classify a change as epic #2369 rule-relocation (#2373). */
@@ -57,6 +58,7 @@ export function readHealthBaseline(projectRoot) {
 /** Persist a health report as the committed baseline (#2373 Wave 2 seed). */
 export function writeHealthBaseline(projectRoot, report) {
     const path = healthBaselinePath(projectRoot);
+    assertWriteTargetSafe(projectRoot, path);
     mkdirSync(dirname(path), { recursive: true });
     writeFileSync(path, `${JSON.stringify(report)}\n`, "utf8");
 }
@@ -170,7 +172,19 @@ export function evaluate(options = {}) {
                 stream: "stderr",
             };
         }
-        writeHealthBaseline(projectRoot, report);
+        try {
+            writeHealthBaseline(projectRoot, report);
+        }
+        catch (err) {
+            if (err instanceof ProjectionContainmentError) {
+                return {
+                    code: 2,
+                    message: `❌ verify:eval-health-relocation: ${err.message}`,
+                    stream: "stderr",
+                };
+            }
+            throw err;
+        }
         return {
             code: 0,
             message: `✓ verify:eval-health-relocation: seeded baseline at ${HEALTH_BASELINE_REL} ` +

package/dist/fs/projection-containment.js

@@ -91,7 +91,7 @@ export function assertProjectionContained(projectDir, targetPath) {
             try {
                 deepestExistingReal = realpathSync(current);
             }
-            catch (err) {
+            catch {
                 throw new ProjectionContainmentError(`projection write refused: could not resolve ${current} on the projection path`, { projectDir: projectAbs, targetPath: targetAbs, offendingPath: current });
             }
         }

package/dist/hooks/cursor-hooks.d.ts

@@ -1,23 +1,9 @@
-/** Cursor ApplyPatch spellings handled by the project adapter, not generic write dispatch. */
+/** Cursor's ApplyPatch payload is parsed directly by the shared hook executable. */
 export declare const APPLY_PATCH_TOOL_NAMES: readonly ["ApplyPatch", "apply_patch"];
 export declare const APPLY_PATCH_HOOK_MATCHER: string;
-/** Generic Cursor write matcher excludes ApplyPatch — adapter owns it (#2764). */
-export declare const CURSOR_GENERIC_WRITE_TOOL_NAMES: ("Edit" | "Write" | "WriteFile" | "CreateFile" | "MultiEdit" | "NotebookEdit" | "StrReplace" | "SearchReplace" | "Delete" | "DeleteFile" | "ApplyPatch" | "apply_patch")[];
-export declare const CURSOR_GENERIC_WRITE_HOOK_MATCHER: string;
-export declare const CURSOR_APPLY_PATCH_ADAPTER_RELATIVE = ".cursor/hooks/deft-cursor-hook-adapter.mjs";
-export declare const DEFT_CURSOR_ADAPTER_COMMAND_MARKER = "deft-cursor-hook-adapter.mjs";
-export declare const CURSOR_APPLY_PATCH_ADAPTER_COMMAND = "node .cursor/hooks/deft-cursor-hook-adapter.mjs ApplyPatch";
-/** Deposited adapter forwards free-form ApplyPatch stdin to hook:dispatch with explicit project root. */
-export declare const CURSOR_APPLY_PATCH_ADAPTER_SOURCE = "#!/usr/bin/env node\nimport { spawnSync } from \"node:child_process\";\nimport { readFileSync } from \"node:fs\";\nimport { resolve } from \"node:path\";\n\nconst projectRoot = resolve(process.cwd());\nconst stdin = readFileSync(0, \"utf8\");\n\nfunction deftCommand() {\n  for (const candidate of [\"deft\", \"directive\"]) {\n    const probe = spawnSync(candidate, [\"--version\"], {\n      encoding: \"utf8\",\n      stdio: \"ignore\",\n      shell: process.platform === \"win32\",\n      windowsHide: true,\n    });\n    if (probe.error === undefined && probe.status === 0) return candidate;\n  }\n  process.stderr.write(\n    \"Directive ApplyPatch adapter: neither deft nor directive is on PATH.\\n\",\n  );\n  process.exit(2);\n}\n\nconst cli = deftCommand();\nconst result = spawnSync(\n  cli,\n  [\n    \"hook:dispatch\",\n    \"--host\",\n    \"cursor\",\n    \"--event\",\n    \"tool.before\",\n    \"--project-root\",\n    projectRoot,\n  ],\n  {\n    input: stdin,\n    encoding: \"utf8\",\n    stdio: [\"pipe\", \"pipe\", \"pipe\"],\n    shell: process.platform === \"win32\",\n    windowsHide: true,\n  },\n);\n\nif (result.stderr) process.stderr.write(result.stderr);\nif (result.error) {\n  process.stderr.write(String(result.error));\n  process.exit(2);\n}\nif (result.status !== 0 && result.status !== null) {\n  if (result.stdout) process.stdout.write(result.stdout);\n  process.exit(result.status);\n}\n// Cursor failClosed treats empty stdout as failure \u2014 normalize allow.\nconst out = (result.stdout ?? \"\").trim();\nprocess.stdout.write((out.length > 0 ? out : '{\"permission\":\"allow\"}') + \"\\n\");\nprocess.exit(0);\n";
-export interface CursorPreToolUseEntry {
-    readonly command: string;
-    readonly matcher?: string;
-    readonly failClosed?: boolean;
-    readonly timeout?: number;
-}
-export declare function cursorApplyPatchAdapterEntry(): CursorPreToolUseEntry;
-/** True when generic and adapter matchers share no tool tokens. */
-export declare function cursorApplyPatchMatchersDisjoint(): boolean;
-/** Fail closed when Cursor hook projection would double-dispatch ApplyPatch (#2764). */
-export declare function assertCursorApplyPatchMatchersDisjoint(): void;
+/**
+ * Cursor uses one disjoint direct-write registration: hook-dispatch recognizes
+ * JSON and free-form ApplyPatch payloads, avoiding an adapter process (#2790).
+ */
+export declare const CURSOR_DIRECT_WRITE_HOOK_MATCHER: string;
 //# sourceMappingURL=cursor-hooks.d.ts.map

package/dist/hooks/cursor-hooks.js

@@ -1,95 +1,10 @@
-import { DIRECT_WRITE_TOOL_NAMES } from "./tools.js";
-/** Cursor ApplyPatch spellings handled by the project adapter, not generic write dispatch. */
+import { DIRECT_WRITE_HOOK_MATCHER } from "./tools.js";
+/** Cursor's ApplyPatch payload is parsed directly by the shared hook executable. */
 export const APPLY_PATCH_TOOL_NAMES = ["ApplyPatch", "apply_patch"];
 export const APPLY_PATCH_HOOK_MATCHER = APPLY_PATCH_TOOL_NAMES.join("|");
-const APPLY_PATCH_TOOLS = new Set(APPLY_PATCH_TOOL_NAMES);
-/** Generic Cursor write matcher excludes ApplyPatch — adapter owns it (#2764). */
-export const CURSOR_GENERIC_WRITE_TOOL_NAMES = DIRECT_WRITE_TOOL_NAMES.filter((name) => !APPLY_PATCH_TOOLS.has(name));
-export const CURSOR_GENERIC_WRITE_HOOK_MATCHER = CURSOR_GENERIC_WRITE_TOOL_NAMES.join("|");
-export const CURSOR_APPLY_PATCH_ADAPTER_RELATIVE = ".cursor/hooks/deft-cursor-hook-adapter.mjs";
-export const DEFT_CURSOR_ADAPTER_COMMAND_MARKER = "deft-cursor-hook-adapter.mjs";
-export const CURSOR_APPLY_PATCH_ADAPTER_COMMAND = `node ${CURSOR_APPLY_PATCH_ADAPTER_RELATIVE} ApplyPatch`;
-/** Deposited adapter forwards free-form ApplyPatch stdin to hook:dispatch with explicit project root. */
-export const CURSOR_APPLY_PATCH_ADAPTER_SOURCE = `#!/usr/bin/env node
-import { spawnSync } from "node:child_process";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-
-const projectRoot = resolve(process.cwd());
-const stdin = readFileSync(0, "utf8");
-
-function deftCommand() {
-  for (const candidate of ["deft", "directive"]) {
-    const probe = spawnSync(candidate, ["--version"], {
-      encoding: "utf8",
-      stdio: "ignore",
-      shell: process.platform === "win32",
-      windowsHide: true,
-    });
-    if (probe.error === undefined && probe.status === 0) return candidate;
-  }
-  process.stderr.write(
-    "Directive ApplyPatch adapter: neither deft nor directive is on PATH.\\n",
-  );
-  process.exit(2);
-}
-
-const cli = deftCommand();
-const result = spawnSync(
-  cli,
-  [
-    "hook:dispatch",
-    "--host",
-    "cursor",
-    "--event",
-    "tool.before",
-    "--project-root",
-    projectRoot,
-  ],
-  {
-    input: stdin,
-    encoding: "utf8",
-    stdio: ["pipe", "pipe", "pipe"],
-    shell: process.platform === "win32",
-    windowsHide: true,
-  },
-);
-
-if (result.stderr) process.stderr.write(result.stderr);
-if (result.error) {
-  process.stderr.write(String(result.error));
-  process.exit(2);
-}
-if (result.status !== 0 && result.status !== null) {
-  if (result.stdout) process.stdout.write(result.stdout);
-  process.exit(result.status);
-}
-// Cursor failClosed treats empty stdout as failure — normalize allow.
-const out = (result.stdout ?? "").trim();
-process.stdout.write((out.length > 0 ? out : '{"permission":"allow"}') + "\\n");
-process.exit(0);
-`;
-export function cursorApplyPatchAdapterEntry() {
-    return {
-        command: CURSOR_APPLY_PATCH_ADAPTER_COMMAND,
-        matcher: APPLY_PATCH_HOOK_MATCHER,
-        failClosed: true,
-        timeout: 5,
-    };
-}
-/** True when generic and adapter matchers share no tool tokens. */
-export function cursorApplyPatchMatchersDisjoint() {
-    const generic = new Set(CURSOR_GENERIC_WRITE_HOOK_MATCHER.split("|"));
-    for (const token of APPLY_PATCH_HOOK_MATCHER.split("|")) {
-        if (generic.has(token))
-            return false;
-    }
-    return true;
-}
-/** Fail closed when Cursor hook projection would double-dispatch ApplyPatch (#2764). */
-export function assertCursorApplyPatchMatchersDisjoint() {
-    if (!cursorApplyPatchMatchersDisjoint()) {
-        throw new Error("Cursor ApplyPatch and generic direct-write matchers overlap — refusing hook deposit (#2764).");
-    }
-}
+/**
+ * Cursor uses one disjoint direct-write registration: hook-dispatch recognizes
+ * JSON and free-form ApplyPatch payloads, avoiding an adapter process (#2790).
+ */
+export const CURSOR_DIRECT_WRITE_HOOK_MATCHER = DIRECT_WRITE_HOOK_MATCHER;
 //# sourceMappingURL=cursor-hooks.js.map

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

@@ -1,9 +1,9 @@
 import type { HookHost } from "../hooks/dispatcher.js";
 import { type HostHooksPolicy } from "../policy/host-hooks.js";
 import type { InitDepositIo } from "./constants.js";
-export { CURSOR_GENERIC_WRITE_HOOK_MATCHER, DEFT_CURSOR_ADAPTER_COMMAND_MARKER, } from "../hooks/cursor-hooks.js";
 export { DIRECT_WRITE_HOOK_MATCHER, SPAWN_HOOK_MATCHER } from "../hooks/tools.js";
-export declare const DEFT_HOOK_COMMAND_MARKER = "deft hook:dispatch";
+export declare const DEFT_HOOK_COMMAND_MARKER = "deft-hook";
+export declare const LEGACY_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";

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

@@ -1,12 +1,11 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { assertDepositContained } from "../deposit/contain.js";
-import { assertCursorApplyPatchMatchersDisjoint, CURSOR_APPLY_PATCH_ADAPTER_RELATIVE, CURSOR_APPLY_PATCH_ADAPTER_SOURCE, CURSOR_GENERIC_WRITE_HOOK_MATCHER, cursorApplyPatchAdapterEntry, DEFT_CURSOR_ADAPTER_COMMAND_MARKER, } from "../hooks/cursor-hooks.js";
 import { DIRECT_WRITE_HOOK_MATCHER, SPAWN_HOOK_MATCHER } from "../hooks/tools.js";
 import { isHostHookDepositEnabled, loadHostHooksPolicyFromProject, } from "../policy/host-hooks.js";
-export { CURSOR_GENERIC_WRITE_HOOK_MATCHER, DEFT_CURSOR_ADAPTER_COMMAND_MARKER, } from "../hooks/cursor-hooks.js";
 export { DIRECT_WRITE_HOOK_MATCHER, SPAWN_HOOK_MATCHER } from "../hooks/tools.js";
-export const DEFT_HOOK_COMMAND_MARKER = "deft hook:dispatch";
+export const DEFT_HOOK_COMMAND_MARKER = "deft-hook";
+export const LEGACY_DEFT_HOOK_COMMAND_MARKER = "deft hook:dispatch";
 export const AGENT_HOOK_PATHS = [
     ".claude/settings.json",
     ".grok/hooks/deft.json",
@@ -64,17 +63,21 @@ function nestedCommands(value) {
     });
 }
 function isManagedNestedGroup(value) {
-    return nestedCommands(value).some((value) => value.includes(DEFT_HOOK_COMMAND_MARKER));
+    return nestedCommands(value).some((command) => command.includes(DEFT_HOOK_COMMAND_MARKER) ||
+        command.includes(LEGACY_DEFT_HOOK_COMMAND_MARKER));
 }
 function isManagedNestedGroupForHost(value, host) {
-    return nestedCommands(value).some((command) => command.includes(DEFT_HOOK_COMMAND_MARKER) && command.includes(`--host ${host}`));
+    return nestedCommands(value).some((command) => (command.includes(DEFT_HOOK_COMMAND_MARKER) ||
+        command.includes(LEGACY_DEFT_HOOK_COMMAND_MARKER)) &&
+        command.includes(`--host ${host}`));
 }
 function isManagedCursorEntry(value) {
     const entry = object(value);
     if (typeof entry?.command !== "string")
         return false;
     return (entry.command.includes(DEFT_HOOK_COMMAND_MARKER) ||
-        entry.command.includes(DEFT_CURSOR_ADAPTER_COMMAND_MARKER));
+        entry.command.includes(LEGACY_DEFT_HOOK_COMMAND_MARKER) ||
+        entry.command.includes("deft-cursor-hook-adapter.mjs"));
 }
 function isManagedCursorEntryForHost(value) {
     return isManagedCursorEntry(value);
@@ -142,7 +145,6 @@ function stripManagedCursorConfig(config, path) {
     return { ...config, version: 1, hooks: nextHooks };
 }
 function mergeCursorConfig(config, path) {
-    assertCursorApplyPatchMatchersDisjoint();
     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));
@@ -150,10 +152,9 @@ function mergeCursorConfig(config, path) {
     hooks.sessionStart = [...session, { command: command("cursor", "session.start"), timeout: 5 }];
     hooks.preToolUse = [
         ...preTool,
-        cursorApplyPatchAdapterEntry(),
         {
             command: command("cursor", "tool.before"),
-            matcher: CURSOR_GENERIC_WRITE_HOOK_MATCHER,
+            matcher: DIRECT_WRITE_HOOK_MATCHER,
             failClosed: true,
             timeout: 5,
         },
@@ -167,15 +168,6 @@ function mergeCursorConfig(config, path) {
     hooks.preCompact = [...preCompact, { command: command("cursor", "session.compact"), timeout: 5 }];
     return { ...config, version: 1, hooks };
 }
-function writeTextIfChanged(path, contents) {
-    if (existsSync(path) && readFileSync(path, "utf8") === contents)
-        return false;
-    mkdirSync(dirname(path), { recursive: true });
-    const temporary = `${path}.deft-${process.pid}.tmp`;
-    writeFileSync(temporary, contents, "utf8");
-    renameSync(temporary, path);
-    return true;
-}
 function writeJsonIfChanged(path, payload) {
     const next = `${JSON.stringify(payload, null, 2)}\n`;
     if (existsSync(path) && readFileSync(path, "utf8") === next)
@@ -246,20 +238,21 @@ export function writeAgentHookDeposit(projectRoot, io = { printf: () => undefine
                 changedPaths.push(item.path);
         }
     }
-    const adapterAbsolute = join(projectRoot, CURSOR_APPLY_PATCH_ADAPTER_RELATIVE);
-    assertDepositContained(projectRoot, adapterAbsolute);
-    if (isHostHookDepositEnabled("cursor", hostHooksPolicy)) {
-        if (writeTextIfChanged(adapterAbsolute, CURSOR_APPLY_PATCH_ADAPTER_SOURCE)) {
-            if (!changedPaths.includes(AGENT_HOOK_PATHS[2])) {
-                changedPaths.push(AGENT_HOOK_PATHS[2]);
-            }
+    const legacyAdapterPaths = [
+        ".cursor/hooks/deft-cursor-hook-adapter.mjs",
+        ".cursor/hooks/deft-cursor-hook-adapter.test.mjs",
+    ];
+    let removedLegacyAdapter = false;
+    for (const relative of legacyAdapterPaths) {
+        const absolute = join(projectRoot, relative);
+        assertDepositContained(projectRoot, absolute);
+        if (existsSync(absolute)) {
+            rmSync(absolute, { force: true });
+            removedLegacyAdapter = true;
         }
     }
-    else if (existsSync(adapterAbsolute)) {
-        rmSync(adapterAbsolute, { force: true });
-        if (!strippedPaths.includes(AGENT_HOOK_PATHS[2])) {
-            strippedPaths.push(AGENT_HOOK_PATHS[2]);
-        }
+    if (removedLegacyAdapter && !changedPaths.includes(AGENT_HOOK_PATHS[2])) {
+        changedPaths.push(AGENT_HOOK_PATHS[2]);
     }
     if (changedPaths.length > 0) {
         io.printf(`Installed Directive agent hooks: ${changedPaths.join(", ")}\n`);
@@ -309,18 +302,11 @@ function hasCursorRegistration(config) {
     const session = Array.isArray(hooks.sessionStart) ? hooks.sessionStart : [];
     const preTool = Array.isArray(hooks.preToolUse) ? hooks.preToolUse : [];
     const preCompact = Array.isArray(hooks.preCompact) ? hooks.preCompact : [];
-    const adapter = cursorApplyPatchAdapterEntry();
     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 === CURSOR_GENERIC_WRITE_HOOK_MATCHER &&
-                hook.failClosed === true);
-        }) &&
-        preTool.some((entry) => {
-            const hook = object(entry);
-            return (hook?.command === adapter.command &&
-                hook.matcher === adapter.matcher &&
+                hook.matcher === DIRECT_WRITE_HOOK_MATCHER &&
                 hook.failClosed === true);
         }) &&
         preTool.some((entry) => {

package/dist/init-deposit/gitignore.js

@@ -11,6 +11,7 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 import { FORBIDDEN_BLANKET_EVAL_LINES, stripGitignoreInlineComment, } from "../triage/bootstrap/gitignore.js";
 /** Directory ignore entry for the hybrid deposit (greenfield only). */
 export const GITIGNORE_DEFT_CORE_LINE = ".deft/core/";
@@ -195,9 +196,13 @@ function reconcileGitignoreFile(projectDir, targetLines, includeDeftCoreRational
         }
     }
     try {
+        assertWriteTargetSafe(projectDir, path);
         writeFileSync(path, body, { encoding: "utf8", mode: 0o644 });
     }
     catch (cause) {
+        if (cause instanceof ProjectionContainmentError) {
+            throw cause;
+        }
         throw new Error(`could not write .gitignore: ${String(cause)}`);
     }
     const finalPresent = collectPresentGitignoreLines(body);

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

@@ -57,6 +57,28 @@ export declare function stageFrameworkPaths(projectDir: string, paths: readonly
  * Refs #2347.
  */
 export declare const STRAY_DEPOSIT_FRAMEWORK_PATHS: readonly ["packages"];
+/**
+ * Deposit-local files generated by init/update that are intentionally absent
+ * from `@deftai/directive-content` (#2804).
+ */
+export declare const DEPOSIT_GENERATED_METADATA_PATHS: readonly ["VERSION"];
+export declare function isDepositGeneratedMetadata(relPath: string): boolean;
+/**
+ * List deposit-relative paths that are absent from the installed content package,
+ * excluding generated deposit metadata such as `VERSION` (#2804).
+ */
+export declare function findPackageAbsentDepositPathsSync(deftDir: string, contentRoot: string): string[];
+export declare function findPackageAbsentDepositPaths(deftDir: string, contentRoot: string): Promise<string[]>;
+export interface PrunePackageAbsentDepositPathsResult {
+    readonly pruned: string[];
+    readonly prunedDirs: string[];
+}
+/**
+ * Remove deposit files not shipped by `@deftai/directive-content`, preserving
+ * generated deposit metadata such as `VERSION` (#2804). Subsumes the legacy
+ * hard-coded `packages/` prune (#2347).
+ */
+export declare function prunePackageAbsentDepositPaths(deftDir: string, contentRoot: string, io: InitDepositIo): Promise<PrunePackageAbsentDepositPathsResult>;
 export interface PruneStrayDepositPathsResult {
     readonly pruned: string[];
 }

package/dist/init-deposit/hygiene.js

@@ -5,9 +5,9 @@
  * Refs #1576, #1453, #1430.
  */
 import { execFileSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { rm, stat } from "node:fs/promises";
-import { join, relative } from "node:path";
+import { existsSync, readdirSync, rmSync } from "node:fs";
+import { readdir, rm, stat } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
 import { gitPorcelain } from "../story-ready/git.js";
 import { CANONICAL_INSTALL_ROOT } from "./constants.js";
 export const CODEQL_CONFIG_REL = ".github/codeql/codeql-config.yml";
@@ -24,7 +24,6 @@ export function installerManagedMatchers() {
         { exact: ".claude/settings.json" },
         { exact: ".grok/hooks/deft.json" },
         { exact: ".cursor/hooks.json" },
-        { exact: ".cursor/hooks/deft-cursor-hook-adapter.mjs" },
         { exact: ".codex/hooks.json" },
         { exact: ".gitattributes" },
         { exact: ".gitignore" },
@@ -146,6 +145,139 @@ export function stageFrameworkPaths(projectDir, paths, seams = {}) {
  * Refs #2347.
  */
 export const STRAY_DEPOSIT_FRAMEWORK_PATHS = ["packages"];
+/**
+ * Deposit-local files generated by init/update that are intentionally absent
+ * from `@deftai/directive-content` (#2804).
+ */
+export const DEPOSIT_GENERATED_METADATA_PATHS = ["VERSION"];
+export function isDepositGeneratedMetadata(relPath) {
+    const normalized = relPath.replace(/\\/g, "/");
+    return DEPOSIT_GENERATED_METADATA_PATHS.includes(normalized);
+}
+function normalizeRelativePath(relPath) {
+    return relPath.replace(/\\/g, "/");
+}
+function listRelativeFilePathsSync(root) {
+    if (!existsSync(root))
+        return [];
+    const results = [];
+    const walk = (dir, prefix) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const rel = normalizeRelativePath(prefix ? `${prefix}/${entry.name}` : entry.name);
+            const abs = join(dir, entry.name);
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory()) {
+                walk(abs, rel);
+            }
+            else if (entry.isFile()) {
+                results.push(rel);
+            }
+        }
+    };
+    walk(root, "");
+    return results;
+}
+async function listRelativeFilePaths(root) {
+    if (!existsSync(root))
+        return [];
+    const results = [];
+    const walk = async (dir, prefix) => {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const rel = normalizeRelativePath(prefix ? `${prefix}/${entry.name}` : entry.name);
+            const abs = join(dir, entry.name);
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory()) {
+                await walk(abs, rel);
+            }
+            else if (entry.isFile()) {
+                results.push(rel);
+            }
+        }
+    };
+    await walk(root, "");
+    return results;
+}
+function contentDirectoryPaths(contentFiles) {
+    const dirs = new Set();
+    for (const file of contentFiles) {
+        let dir = dirname(file);
+        while (dir && dir !== ".") {
+            dirs.add(normalizeRelativePath(dir));
+            const parent = dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    return dirs;
+}
+/**
+ * List deposit-relative paths that are absent from the installed content package,
+ * excluding generated deposit metadata such as `VERSION` (#2804).
+ */
+export function findPackageAbsentDepositPathsSync(deftDir, contentRoot) {
+    const depositFiles = listRelativeFilePathsSync(deftDir);
+    const contentFiles = new Set(listRelativeFilePathsSync(contentRoot));
+    return depositFiles
+        .filter((rel) => !contentFiles.has(rel) && !isDepositGeneratedMetadata(rel))
+        .sort();
+}
+export async function findPackageAbsentDepositPaths(deftDir, contentRoot) {
+    const depositFiles = await listRelativeFilePaths(deftDir);
+    const contentFiles = new Set(await listRelativeFilePaths(contentRoot));
+    return depositFiles
+        .filter((rel) => !contentFiles.has(rel) && !isDepositGeneratedMetadata(rel))
+        .sort();
+}
+async function pruneEmptyParentsForFile(deftDir, contentDirs, relFile) {
+    const prunedDirs = [];
+    let rel = dirname(relFile);
+    while (rel && rel !== ".") {
+        const normalized = normalizeRelativePath(rel);
+        if (contentDirs.has(normalized))
+            break;
+        const abs = join(deftDir, rel);
+        try {
+            if (!existsSync(abs) || readdirSync(abs).length !== 0)
+                break;
+            rmSync(abs, { recursive: false, force: true });
+            prunedDirs.push(normalized);
+        }
+        catch {
+            break;
+        }
+        rel = dirname(rel);
+    }
+    return prunedDirs;
+}
+/**
+ * Remove deposit files not shipped by `@deftai/directive-content`, preserving
+ * generated deposit metadata such as `VERSION` (#2804). Subsumes the legacy
+ * hard-coded `packages/` prune (#2347).
+ */
+export async function prunePackageAbsentDepositPaths(deftDir, contentRoot, io) {
+    const absent = await findPackageAbsentDepositPaths(deftDir, contentRoot);
+    const contentDirs = contentDirectoryPaths(listRelativeFilePathsSync(contentRoot));
+    const pruned = [];
+    const prunedDirs = [];
+    for (const rel of absent) {
+        try {
+            rmSync(join(deftDir, rel), { force: true });
+            pruned.push(rel);
+            prunedDirs.push(...(await pruneEmptyParentsForFile(deftDir, contentDirs, rel)));
+        }
+        catch (cause) {
+            io.printf(`Warning: could not prune .deft/core/${rel}: ${String(cause)}\n`);
+        }
+    }
+    if (pruned.length > 0) {
+        io.printf(`Pruned ${pruned.length} package-absent deposit file(s) not shipped by @deftai/directive-content (#2804).\n`);
+    }
+    return { pruned, prunedDirs };
+}
 /**
  * Remove framework-source subdirectories from `.deft/core/` that are not
  * present in the deposited content package (#2347). Silently skips any path

package/dist/init-deposit/legacy-detect.d.ts

@@ -25,7 +25,7 @@
  */
 /** Non-zero exit code for a use-time legacy-layout refusal (needs-action). */
 export declare const LEGACY_LAYOUT_REFUSED_EXIT_CODE = 2;
-export type LegacyLayoutKind = "orphan-deft-version" | "legacy-deft-prefixed" | "git-clone-or-submodule" | "pre-v0.27-sentinel-agents-md";
+export type LegacyLayoutKind = "orphan-deft-version" | "legacy-deft-prefixed" | "git-clone-or-submodule" | "pre-v0.27-sentinel-agents-md" | "dual-layout";
 export interface LegacyLayoutDetection {
     readonly legacy: boolean;
     readonly kind: LegacyLayoutKind | null;
@@ -37,6 +37,12 @@ export interface LegacyDetectSeams {
     readonly isDir?: (p: string) => boolean;
     readonly readText?: (p: string) => string | null;
 }
+/**
+ * Detect a post-bridge dual-layout: canonical `.deft/core/` plus a leftover
+ * framework-marked `deft/` tree. Doctor-only -- the npm deposit path treats
+ * `.deft/core/` as canonical and must not refuse here (#2805 / #2804 wiring).
+ */
+export declare function detectDualLayout(projectDir: string, seams?: LegacyDetectSeams): LegacyLayoutDetection | null;
 /**
  * Classify the on-disk layout at `projectDir`. Returns `legacy: false` for the
  * canonical `.deft/core/` vendored layout and for a greenfield project (so init
@@ -58,4 +64,22 @@ export declare function buildLegacyRefusalMessage(command: "init" | "update", de
 export declare function buildLegacyRefusalJson(command: "init" | "update", projectDir: string, detection: LegacyLayoutDetection): Record<string, unknown>;
 /** One-line doctor signpost carrying the stable URL (no baked version/command). */
 export declare function legacyLayoutSignpostLine(detection: LegacyLayoutDetection): string;
+/** Doctor / npm signpost for the post-bridge dual-layout state (#2805). */
+export declare function dualLayoutSignpostLine(detection: LegacyLayoutDetection): string;
+export interface LegacyDeftCleanupSeams {
+    readonly gitPorcelain?: (projectRoot: string) => string | null;
+    readonly runGitRm?: (projectDir: string, relPath: string) => void;
+    readonly removeDir?: (absPath: string) => void;
+}
+export type LegacyDeftCleanupAction = "removed" | "staged" | "refused" | "skipped";
+export interface LegacyDeftCleanupResult {
+    readonly ok: boolean;
+    readonly action: LegacyDeftCleanupAction;
+    readonly detail: string;
+}
+/**
+ * Remove a clean tracked legacy `deft/` tree after bridge migration (#2805).
+ * Refuses when the tree has local modifications or untracked files.
+ */
+export declare function tryCleanupLegacyDeftTree(projectDir: string, seams?: LegacyDeftCleanupSeams): LegacyDeftCleanupResult;
 //# sourceMappingURL=legacy-detect.d.ts.map