@deftai/directive-core 0.83.0 → 0.85.0

package/dist/doctor/npm-registry.d.ts

@@ -0,0 +1,23 @@
+import type { OutputSink } from "./output.js";
+import type { Finding, NpmConfigGet, NpmConfigGetResult } from "./types.js";
+/** Seams for the read-only npm registry routing diagnostic. */
+export interface NpmRegistryMirrorSeams {
+    readonly runNpmConfigGet?: NpmConfigGet;
+}
+/**
+ * Read one npm configuration key without a shell.
+ *
+ * `npm config get` reads local/user configuration only; it does not resolve a
+ * package or contact a registry. Failures are returned explicitly so doctor can
+ * skip this advisory without turning a missing npm binary into a hard error.
+ */
+export declare function defaultNpmConfigGet(key: string, cwd: string): NpmConfigGetResult;
+/**
+ * Warn when `@deftai/*` resolves through a non-public npm registry.
+ *
+ * The finding intentionally records only whether the scoped or default key won
+ * precedence. It never includes the configured URL, which may contain internal
+ * hostnames or credentials.
+ */
+export declare function runNpmRegistryMirrorCheck(projectRoot: string, sink: OutputSink, addFinding: (finding: Finding) => void, seams?: NpmRegistryMirrorSeams): void;
+//# sourceMappingURL=npm-registry.d.ts.map

package/dist/doctor/npm-registry.js

@@ -0,0 +1,128 @@
+import { spawnSync } from "node:child_process";
+import { NPM_REGISTRY_MIRROR_DOC_URL, PUBLIC_NPM_REGISTRY } from "./constants.js";
+const CHECK_NAME = "npm-registry-mirror";
+const DEFT_SCOPE_REGISTRY_KEY = "@deftai:registry";
+const DEFAULT_REGISTRY_KEY = "registry";
+const UNSET_NPM_VALUES = new Set(["", "null", "undefined"]);
+/**
+ * Read one npm configuration key without a shell.
+ *
+ * `npm config get` reads local/user configuration only; it does not resolve a
+ * package or contact a registry. Failures are returned explicitly so doctor can
+ * skip this advisory without turning a missing npm binary into a hard error.
+ */
+export function defaultNpmConfigGet(key, cwd) {
+    try {
+        const proc = spawnSync("npm", ["config", "get", key], {
+            cwd,
+            encoding: "utf8",
+            shell: false,
+            timeout: 5_000,
+            windowsHide: true,
+        });
+        return {
+            ok: proc.status === 0,
+            value: typeof proc.stdout === "string" ? proc.stdout.trim() : "",
+        };
+    }
+    catch {
+        return { ok: false, value: "" };
+    }
+}
+function configuredValue(value) {
+    const trimmed = value.trim();
+    return UNSET_NPM_VALUES.has(trimmed.toLowerCase()) ? null : trimmed;
+}
+function effectiveRegistry(runConfigGet, projectRoot) {
+    let scoped;
+    try {
+        scoped = runConfigGet(DEFT_SCOPE_REGISTRY_KEY, projectRoot);
+    }
+    catch {
+        return null;
+    }
+    if (!scoped.ok) {
+        return null;
+    }
+    const scopedValue = configuredValue(scoped.value);
+    if (scopedValue !== null) {
+        return { source: "scoped", value: scopedValue };
+    }
+    let fallback;
+    try {
+        fallback = runConfigGet(DEFAULT_REGISTRY_KEY, projectRoot);
+    }
+    catch {
+        return null;
+    }
+    if (!fallback.ok) {
+        return null;
+    }
+    const fallbackValue = configuredValue(fallback.value);
+    return fallbackValue === null ? null : { source: "default", value: fallbackValue };
+}
+function isValidRegistryUrl(value) {
+    try {
+        const parsed = new URL(value);
+        return (parsed.protocol === "https:" || parsed.protocol === "http:") && parsed.hostname !== "";
+    }
+    catch {
+        return false;
+    }
+}
+function isCanonicalPublicRegistry(value) {
+    try {
+        const parsed = new URL(value);
+        return (parsed.protocol === "https:" &&
+            parsed.hostname === "registry.npmjs.org" &&
+            parsed.port === "" &&
+            (parsed.pathname === "" || parsed.pathname === "/") &&
+            parsed.username === "" &&
+            parsed.password === "" &&
+            parsed.search === "" &&
+            parsed.hash === "");
+    }
+    catch {
+        return false;
+    }
+}
+function skipFinding(addFinding) {
+    addFinding({
+        severity: "skip",
+        message: `${CHECK_NAME}: skip -- npm registry configuration is unavailable or invalid`,
+        check: CHECK_NAME,
+        status: "skip",
+    });
+}
+/**
+ * Warn when `@deftai/*` resolves through a non-public npm registry.
+ *
+ * The finding intentionally records only whether the scoped or default key won
+ * precedence. It never includes the configured URL, which may contain internal
+ * hostnames or credentials.
+ */
+export function runNpmRegistryMirrorCheck(projectRoot, sink, addFinding, seams = {}) {
+    const selected = effectiveRegistry(seams.runNpmConfigGet ?? defaultNpmConfigGet, projectRoot);
+    if (selected === null || !isValidRegistryUrl(selected.value)) {
+        skipFinding(addFinding);
+        return;
+    }
+    if (isCanonicalPublicRegistry(selected.value)) {
+        return;
+    }
+    const message = `${CHECK_NAME}: @deftai packages resolve through a non-public npm registry. ` +
+        "Corporate mirrors can return E404/ETARGET or silently serve stale @latest metadata. " +
+        `Where organization policy permits, retry with \`npm i -g @deftai/directive@latest --registry=${PUBLIC_NPM_REGISTRY}\` ` +
+        `or add \`@deftai:registry=${PUBLIC_NPM_REGISTRY}\` to \`.npmrc\`. ` +
+        `Otherwise ask your registry administrator to sync the @deftai packages. See ${NPM_REGISTRY_MIRROR_DOC_URL}.`;
+    sink.warn(message);
+    addFinding({
+        severity: "warning",
+        message,
+        check: CHECK_NAME,
+        status: "non-public",
+        registry_source: selected.source,
+        suggestion: NPM_REGISTRY_MIRROR_DOC_URL,
+    });
+}
+//# sourceMappingURL=npm-registry.js.map

package/dist/doctor/npm-view.d.ts

@@ -0,0 +1,10 @@
+export interface NpmViewVersionResult {
+    readonly ok: boolean;
+    readonly version: string;
+}
+/**
+ * Query the canonical public registry for the latest published Directive
+ * version, independent of the consumer's configured corporate mirror.
+ */
+export declare function defaultNpmViewVersion(): NpmViewVersionResult;
+//# sourceMappingURL=npm-view.d.ts.map

package/dist/doctor/npm-view.js

@@ -0,0 +1,31 @@
+import { spawnSync } from "node:child_process";
+import { NPM_PACKAGE_NAME, PUBLIC_NPM_REGISTRY } from "./constants.js";
+/**
+ * Query the canonical public registry for the latest published Directive
+ * version, independent of the consumer's configured corporate mirror.
+ */
+export function defaultNpmViewVersion() {
+    try {
+        const proc = spawnSync("npm", [
+            "view",
+            NPM_PACKAGE_NAME,
+            "version",
+            `--registry=${PUBLIC_NPM_REGISTRY}`,
+            "--ignore-scripts",
+        ], {
+            encoding: "utf8",
+            shell: false,
+            timeout: 15_000,
+            windowsHide: true,
+        });
+        if (proc.error !== undefined || proc.status !== 0) {
+            return { ok: false, version: "" };
+        }
+        const version = (typeof proc.stdout === "string" ? proc.stdout : "").trim().split("\n")[0]?.trim() ?? "";
+        return { ok: version.length > 0, version };
+    }
+    catch {
+        return { ok: false, version: "" };
+    }
+}
+//# sourceMappingURL=npm-view.js.map

package/dist/doctor/payload-staleness.js

@@ -2,8 +2,9 @@ import { spawnSync } from "node:child_process";
 import { dirname, join } from "node:path";
 import { detectCanonicalVendoredManifest, isNpmManaged } from "../init-deposit/migrate.js";
 import { isPublishable } from "../release/version.js";
-import { CANONICAL_UPGRADE_COMMAND, NPM_PACKAGE_NAME, upgradeCommandFor, VENDORED_NPM_DEPOSIT_UPGRADE_COMMAND, } from "./constants.js";
+import { CANONICAL_UPGRADE_COMMAND, upgradeCommandFor, VENDORED_NPM_DEPOSIT_UPGRADE_COMMAND, } from "./constants.js";
 import { locateManifest, parseInstallManifest } from "./manifest.js";
+import { defaultNpmViewVersion } from "./npm-view.js";
 import { readTextSafe, resolveDefaultFrameworkRoot } from "./paths.js";
 import { evaluateReleaseAvailability } from "./release-availability.js";
 function isDeftFrameworkRepo(projectRoot, readText = readTextSafe) {
@@ -40,14 +41,6 @@ function parseRemoteSha(stdout) {
     const firstLine = stdout.split("\n").find((ln) => ln.trim()) ?? "";
     return firstLine.trim().split(/\s+/)[0] ?? "";
 }
-function defaultNpmViewVersion() {
-    const proc = spawnSync("npm", ["view", NPM_PACKAGE_NAME, "version"], {
-        encoding: "utf8",
-        timeout: 15_000,
-    });
-    const version = (proc.stdout ?? "").trim().split("\n")[0]?.trim() ?? "";
-    return { ok: proc.status === 0 && version.length > 0, version };
-}
 function emitReleaseAvailable(checkName, installedVersion, latestVersion, ref, upgradeCommand, sink, addFinding) {
     const msg = `Newer framework release available (installed v${installedVersion}; ` +
         `latest v${latestVersion} from npm registry). ` +

package/dist/doctor/signpost-checks.d.ts

@@ -1,7 +1,8 @@
 import { type CheckSeams } from "./checks.js";
+import { type NpmRegistryMirrorSeams } from "./npm-registry.js";
 import type { OutputSink } from "./output.js";
 import type { Finding } from "./types.js";
-export interface LocalSignpostSeams extends CheckSeams {
+export interface LocalSignpostSeams extends CheckSeams, NpmRegistryMirrorSeams {
     readonly runningInsideDeftRepo?: (root: string) => boolean;
 }
 /** Lightweight, local-only signpost probes for the throttle-skip path (#1997). */

package/dist/doctor/signpost-checks.js

@@ -1,4 +1,5 @@
 import { checkCanonicalVendoredNpmSignpost, checkLegacyLayout } from "./checks.js";
+import { runNpmRegistryMirrorCheck } from "./npm-registry.js";
 import { runningInsideDeftRepo } from "./paths.js";
 /** Lightweight, local-only signpost probes for the throttle-skip path (#1997). */
 export function runLocalSignpostChecks(projectRoot, sink, addFinding, seams = {}) {
@@ -6,6 +7,7 @@ export function runLocalSignpostChecks(projectRoot, sink, addFinding, seams = {}
     if (insideDeft) {
         return;
     }
+    runNpmRegistryMirrorCheck(projectRoot, sink, addFinding, seams);
     for (const result of [
         checkLegacyLayout(projectRoot, seams),
         checkCanonicalVendoredNpmSignpost(projectRoot, seams),

package/dist/doctor/types.d.ts

@@ -30,6 +30,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 +106,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;

package/dist/eval/readback.js

@@ -1,5 +1,6 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 import { MAX_LINE_CHARS } from "../triage/welcome/constants.js";
 import { evaluateHealth, healthHistoryPath } from "./health.js";
 /** Repeat-suppression window for the budgeted eval session nudge (#1703 / #1279 parity). */
@@ -124,10 +125,14 @@ function appendEvalReadbackHistory(projectRoot, nudgeKey, line, options = {}) {
         line,
     };
     try {
+        assertWriteTargetSafe(projectRoot, path);
         mkdirSync(join(path, ".."), { recursive: true });
         appendFileSync(path, `${JSON.stringify(record)}\n`, "utf8");
     }
-    catch {
+    catch (err) {
+        if (err instanceof ProjectionContainmentError) {
+            throw err;
+        }
         // observability only
     }
 }

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/hooks/dispatcher.d.ts

@@ -67,6 +67,8 @@ export declare function toProjectRelativePosix(projectRoot: string, targetPath:
  * planning, not implementation dispatch — exempt from the active-scope gate (#2625).
  */
 export declare function isProposedLifecycleWrite(projectRoot: string, targetPath: string | null): boolean;
+/** Normalize hook project-root resolution on Windows (doubled drive + MSYS `/c/...`). */
+export declare function normalizeHookProjectRoot(path: string): string;
 export declare function projectRootFromHookPayload(payload: unknown, fallback: string): string;
 export declare function isHookHost(value: string): value is HookHost;
 export declare function isHookEvent(value: string): value is HookEvent;

package/dist/hooks/dispatcher.js

@@ -164,17 +164,59 @@ export function isProposedLifecycleWrite(projectRoot, targetPath) {
 function isWindowsDriveOnlyRoot(value) {
     return /^[A-Za-z]:[/\\]?$/.test(value.trim());
 }
+function hookPayloadRootCandidates(input) {
+    const candidates = [];
+    const push = (value) => {
+        if (typeof value === "string" && value.trim().length > 0) {
+            candidates.push(value.trim());
+        }
+    };
+    push(input.workspaceRoot);
+    push(input.workspace_root);
+    const workspaceRoots = input.workspace_roots;
+    if (Array.isArray(workspaceRoots)) {
+        for (const entry of workspaceRoots)
+            push(entry);
+    }
+    push(input.cwd);
+    return candidates;
+}
+/** Collapse join('C:', 'c:\\...') doubled drive prefix on Windows (#2787). */
+function collapseDoubledWindowsDrivePrefix(path) {
+    return path.replace(/^([A-Za-z]:\\)(?=[A-Za-z]:\\)/i, "");
+}
+function msysPathToWin32(path) {
+    const match = /^\/([a-zA-Z])\/(.*)$/.exec(path.trim());
+    if (match === null || match[1] === undefined || match[2] === undefined)
+        return null;
+    return `${match[1].toUpperCase()}:\\${match[2].replace(/\//g, "\\")}`;
+}
+/** Normalize hook project-root resolution on Windows (doubled drive + MSYS `/c/...`). */
+export function normalizeHookProjectRoot(path) {
+    if (process.platform !== "win32")
+        return resolve(path);
+    const trimmed = path.trim();
+    const msys = msysPathToWin32(trimmed);
+    let resolved = resolve(msys ?? trimmed);
+    const collapsed = collapseDoubledWindowsDrivePrefix(resolved);
+    if (collapsed !== resolved) {
+        resolved = resolve(collapsed);
+    }
+    if (/^[a-z]:\\/.test(resolved)) {
+        resolved = `${resolved.charAt(0).toUpperCase()}${resolved.slice(1)}`;
+    }
+    return resolved;
+}
 export function projectRootFromHookPayload(payload, fallback) {
+    const fallbackResolved = normalizeHookProjectRoot(fallback);
     const input = record(payload);
-    const fallbackResolved = resolve(fallback);
     if (input === null)
         return fallbackResolved;
-    const workspaceRoots = input.workspace_roots;
-    const candidate = firstString(input.workspaceRoot, input.workspace_root, Array.isArray(workspaceRoots) ? workspaceRoots[0] : null, input.cwd);
-    if (candidate === null || isWindowsDriveOnlyRoot(candidate)) {
-        return fallbackResolved;
+    const usable = hookPayloadRootCandidates(input).find((candidate) => !isWindowsDriveOnlyRoot(candidate));
+    if (usable !== undefined) {
+        return normalizeHookProjectRoot(usable);
     }
-    return resolve(candidate);
+    return fallbackResolved;
 }
 export function isHookHost(value) {
     return HOOK_HOSTS.includes(value);

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";