@westbayberry/dg 2.0.11 → 2.2.0

package/dist/service/state.js

@@ -1,10 +1,11 @@
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { dirname, isAbsolute, join, relative } from "node:path";
 import { randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { loadUserConfig } from "../config/settings.js";
 import { applyTrustInstall, applyTrustUninstall, readCertificateFingerprints, readServiceTrustRecord, renderTrustStorePlanLines, resolveTrustInstallPlan, TrustStoreError, TrustToolMissingError, writeServiceTrustRecord } from "./trust-store.js";
+import { clearTrustRefreshError, readTrustRefreshError } from "./trust-refresh.js";
 import { acquireLockSync, cleanupSessionSync, createSessionSync, preserveCorruptCleanupRegistrySync, resolveDgPaths, CLEANUP_REGISTRY_LOCK } from "../state/index.js";
 export const SERVICE_SENTINEL = "dg-service-mode-v1";
 export const TRUST_SENTINEL = "dg-service-trust-v1";
@@ -292,6 +293,7 @@ export function installServiceTrust(env, now = new Date()) {
         const plan = trustStoreOperation(() => resolveTrustInstallPlan(runtime.caPath, env ?? process.env));
         const existing = readServiceTrustRecord(paths.trustRecordPath, TRUST_SENTINEL);
         if (existing && existing.fingerprintSha256 === plan.fingerprintSha256 && existing.provider === plan.provider && existing.target === plan.target) {
+            clearTrustRefreshError(paths.serviceDir);
             const state = {
                 ...current,
                 trustInstalled: true,
@@ -311,6 +313,7 @@ export function installServiceTrust(env, now = new Date()) {
             trustStoreOperation(() => applyTrustUninstall(existing));
         }
         const record = trustStoreOperation(() => applyTrustInstall(plan, now, TRUST_SENTINEL));
+        clearTrustRefreshError(paths.serviceDir);
         const state = {
             ...current,
             trustInstalled: true,
@@ -339,6 +342,7 @@ export function uninstallServiceTrust(env, now = new Date()) {
         if (record) {
             trustStoreOperation(() => applyTrustUninstall(record));
         }
+        clearTrustRefreshError(paths.serviceDir);
         const removedTrust = removeFile(paths.trustRecordPath);
         if (!current.configured && !removedTrust) {
             return {
@@ -518,31 +522,42 @@ function readState(paths) {
 function applyRuntimeDiagnostics(paths, state) {
     const runtime = readRuntime(paths) ?? state.proxy;
     if (!runtime) {
-        return state;
+        return withTrustRefreshError(paths, state);
     }
     const drift = detectTrustDrift(state.trust, runtime);
     if (!state.running) {
-        return {
+        return withTrustRefreshError(paths, {
             ...state,
             proxy: runtime,
             trustDrift: drift,
             lastError: "stale service runtime state: runtime file exists while service is stopped"
-        };
+        });
     }
     const health = runtimeHealth(runtime);
     if (!health.healthy) {
-        return {
+        return withTrustRefreshError(paths, {
             ...state,
             running: false,
             proxy: runtime,
             trustDrift: drift,
             lastError: `stale service runtime state: ${health.reason}`
-        };
+        });
     }
-    return {
+    return withTrustRefreshError(paths, {
         ...state,
         proxy: runtime,
         trustDrift: drift
+    });
+}
+function withTrustRefreshError(paths, state) {
+    const refreshError = readTrustRefreshError(paths.serviceDir);
+    if (!refreshError) {
+        return state;
+    }
+    return {
+        ...state,
+        lastError: state.lastError
+            ?? `service CA trust refresh failed at ${refreshError.at}: ${refreshError.message}. Run 'dg service trust install --yes' to repair OS trust for the rotated CA.`
     };
 }
 function runtimeHealth(runtime) {
@@ -711,7 +726,7 @@ function cleanupRuntime(paths, runtime) {
     if (runtime?.pid && processIsAlive(runtime.pid)) {
         killProcess(runtime.pid);
     }
-    if (runtime?.sessionDir && runtime.sessionDir.startsWith(paths.paths.sessionsDir)) {
+    if (runtime?.sessionDir && isContainedIn(paths.paths.sessionsDir, runtime.sessionDir)) {
         rmSync(runtime.sessionDir, {
             force: true,
             recursive: true
@@ -719,6 +734,10 @@ function cleanupRuntime(paths, runtime) {
     }
     removeFile(paths.runtimePath);
 }
+function isContainedIn(parent, child) {
+    const related = relative(parent, child);
+    return related.length > 0 && !related.startsWith("..") && !isAbsolute(related);
+}
 function processIsAlive(pid) {
     if (pid <= 0) {
         return false;

package/dist/service/trust-refresh.js

@@ -0,0 +1,92 @@
+import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { applyTrustInstall, applyTrustUninstall, readServiceTrustRecord, resolveTrustInstallPlan, writeServiceTrustRecord } from "./trust-store.js";
+export const TRUST_REFRESH_ERROR_FILENAME = "trust-refresh-error.json";
+export function trustRefreshErrorPath(serviceDir) {
+    return join(serviceDir, TRUST_REFRESH_ERROR_FILENAME);
+}
+export function readTrustRefreshError(serviceDir) {
+    try {
+        const path = trustRefreshErrorPath(serviceDir);
+        if (!existsSync(path)) {
+            return undefined;
+        }
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (typeof parsed.at !== "string" || typeof parsed.message !== "string") {
+            return undefined;
+        }
+        return {
+            at: parsed.at,
+            message: parsed.message
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function clearTrustRefreshError(serviceDir) {
+    rmSync(trustRefreshErrorPath(serviceDir), {
+        force: true
+    });
+}
+export function refreshServiceTrustAfterCaRotation(options) {
+    const record = readServiceTrustRecord(options.trustRecordPath, options.sentinel);
+    if (!record) {
+        return;
+    }
+    try {
+        const plan = resolveTrustInstallPlan(options.caPath, options.env);
+        applyTrustUninstall(record);
+        const next = applyTrustInstall(plan, options.now ?? new Date(), options.sentinel);
+        sweepStaleDgTrustFiles(next.provider, next.target);
+        writeServiceTrustRecord(options.trustRecordPath, next);
+        clearTrustRefreshError(options.serviceDir);
+    }
+    catch (error) {
+        writeTrustRefreshError(options.serviceDir, error, options.now ?? new Date());
+    }
+}
+function sweepStaleDgTrustFiles(provider, targetPath) {
+    if (provider === "darwin-user-keychain") {
+        return;
+    }
+    const dir = dirname(targetPath);
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (!/^dependency-guardian-[0-9a-f]{16}\.(pem|crt)$/.test(entry)) {
+            continue;
+        }
+        const path = join(dir, entry);
+        if (path === targetPath) {
+            continue;
+        }
+        rmSync(path, {
+            force: true
+        });
+    }
+}
+function writeTrustRefreshError(serviceDir, error, now) {
+    try {
+        mkdirSync(serviceDir, {
+            recursive: true,
+            mode: 0o700
+        });
+        const record = {
+            at: now.toISOString(),
+            message: error instanceof Error ? error.message : String(error)
+        };
+        writeFileSync(trustRefreshErrorPath(serviceDir), `${JSON.stringify(record, null, 2)}\n`, {
+            encoding: "utf8",
+            mode: 0o600
+        });
+    }
+    catch {
+        return;
+    }
+}

package/dist/service/worker.js

@@ -1,6 +1,8 @@
 import { createServer } from "node:http";
 import { readFileSync, rmSync, writeFileSync } from "node:fs";
 import { startProductionHttpProxy } from "../proxy/server.js";
+import { resolveServicePaths, TRUST_SENTINEL } from "./state.js";
+import { refreshServiceTrustAfterCaRotation } from "./trust-refresh.js";
 const sessionPath = process.argv[2];
 const apiBaseUrl = process.argv[3];
 const runtimePath = process.argv[4];
@@ -37,11 +39,31 @@ process.on("SIGTERM", () => {
 process.on("SIGINT", () => {
     close().finally(() => process.exit(0));
 });
+function exitOnFatal(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    try {
+        process.stderr.write(`dg service worker: unexpected error — ${message}\n`);
+    }
+    catch {
+        // stderr is gone; nothing left to report to.
+    }
+    close().finally(() => process.exit(1));
+}
+process.on("uncaughtException", exitOnFatal);
+process.on("unhandledRejection", exitOnFatal);
+const servicePaths = resolveServicePaths(process.env);
 proxy = await startProductionHttpProxy({
     session,
     apiBaseUrl: requiredApiBaseUrl,
     classification,
-    env: process.env
+    env: process.env,
+    onCaRotate: () => refreshServiceTrustAfterCaRotation({
+        serviceDir: servicePaths.serviceDir,
+        trustRecordPath: servicePaths.trustRecordPath,
+        sentinel: TRUST_SENTINEL,
+        caPath: session.files.ca,
+        env: process.env
+    })
 });
 healthServer = await startHealthServer(proxy.port);
 const healthAddress = healthServer.address();

package/dist/setup/activate-shell.js

@@ -0,0 +1,28 @@
+import { spawnSync } from "node:child_process";
+import { basename } from "node:path";
+import { isCiEnv } from "../presentation/mode.js";
+export function activationOffer(options = {}) {
+    const env = options.env ?? process.env;
+    if (env.DG_ACTIVATED_SHELL) {
+        return "none";
+    }
+    const stdin = options.stdin ?? process.stdin;
+    const stdout = options.stdout ?? process.stdout;
+    if (!stdin.isTTY || !stdout.isTTY || isCiEnv(env)) {
+        return "hint";
+    }
+    return "prompt";
+}
+// dg cannot mutate the parent shell's environment, so activation nests a protected interactive child shell.
+export function activateShell(options = {}) {
+    const env = options.env ?? process.env;
+    const spawner = options.spawner ?? defaultShellSpawner;
+    const binary = env.SHELL || "/bin/sh";
+    const name = basename(binary);
+    return spawner({
+        binary,
+        args: name === "bash" || name === "zsh" ? ["-i"] : [],
+        env: { ...env, DG_ACTIVATED_SHELL: "1" }
+    });
+}
+const defaultShellSpawner = (request) => spawnSync(request.binary, request.args, { stdio: "inherit", env: request.env }).status ?? 0;

package/dist/setup/git-hook.js

@@ -1,8 +1,9 @@
 import { spawnSync } from "node:child_process";
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
-import { isAbsolute, join, resolve, sep } from "node:path";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { randomBytes } from "node:crypto";
 import { acquireLockSync, CLEANUP_REGISTRY_LOCK, resolveDgPaths } from "../state/index.js";
+import { resolveToolPath } from "../util/external-tool.js";
 import { gitTrimmed } from "../util/git.js";
 import { GUARD_HOOK_SENTINEL, SETUP_UNINSTALL_LOCK, SETUP_UNINSTALL_LOCK_STALE_MS, chainedHookOriginal, guardHookScript, mergeRegistry, readRegistry, reverseGitHookEntry, writeRegistry } from "./plan.js";
 export { GUARD_HOOK_SENTINEL } from "./plan.js";
@@ -84,7 +85,40 @@ function registryOriginal(context) {
     const entry = readRegistry(context.paths).registry.entries.find((candidate) => candidate.kind === "git-hook" && candidate.owner === "dg" && candidate.path === context.hookTarget);
     return entry?.original ?? null;
 }
+function isSymlinkPath(path) {
+    try {
+        return lstatSync(path).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+function writeHookAtomic(target, content) {
+    const tmp = join(dirname(target), `.pre-commit.dg-${randomBytes(6).toString("hex")}.tmp`);
+    writeFileSync(tmp, content, { encoding: "utf8", mode: 0o755, flag: "wx" });
+    try {
+        renameSync(tmp, target);
+    }
+    catch (error) {
+        rmSync(tmp, { force: true });
+        throw error;
+    }
+}
 export function applyGitHook(context, now = new Date()) {
+    if (gitHookState(context) !== "foreign" && isSymlinkPath(context.hookTarget)) {
+        return {
+            hookTarget: context.hookTarget,
+            chainedOriginal: null,
+            checks: [
+                {
+                    name: "hook-writable",
+                    ok: false,
+                    detail: `${context.hookTarget} is a symlink; dg refuses to replace it — remove the link or point it at a real file, then re-run dg guard-commit`
+                }
+            ],
+            active: false
+        };
+    }
     const lock = acquireLockSync(context.paths, SETUP_UNINSTALL_LOCK, { staleMs: SETUP_UNINSTALL_LOCK_STALE_MS });
     let chainedOriginal = null;
     try {
@@ -98,7 +132,7 @@ export function applyGitHook(context, now = new Date()) {
         else if (state === "managed") {
             chainedOriginal = chainedHookOriginal(hookText(context.hookTarget)) ?? registryOriginal(context);
         }
-        writeFileSync(context.hookTarget, guardHookScript(context.dgPath, chainedOriginal), { encoding: "utf8", mode: 0o755 });
+        writeHookAtomic(context.hookTarget, guardHookScript(context.dgPath, chainedOriginal));
         chmodSync(context.hookTarget, 0o755);
         const entry = {
             kind: "git-hook",
@@ -176,7 +210,11 @@ function runSelfTest(context) {
     if (!existsSync(context.hookTarget) || !isManaged(context.hookTarget)) {
         return { ok: false, detail: "no dg hook to exercise" };
     }
-    const result = spawnSync("sh", [context.hookTarget], {
+    const sh = resolveToolPath("sh", context.env);
+    if (!sh) {
+        return { ok: false, detail: "sh not found on PATH; hook not exercised" };
+    }
+    const result = spawnSync(sh, [context.hookTarget], {
         cwd: context.root,
         env: { ...context.env, [GUARD_SELFTEST_ENV]: "1" },
         encoding: "utf8",
@@ -219,6 +257,13 @@ export function gitHookStatusState(options = {}) {
     const installedHere = registry.entries.some((entry) => entry.kind === "git-hook" && entry.owner === "dg" && isUnderRoot(entry.path, context.root));
     return installedHere ? "dead" : "off";
 }
+export function commitGuardOffer(options = {}) {
+    const resolved = resolveGitRepo(options);
+    if ("error" in resolved) {
+        return null;
+    }
+    return gitHookStatusState(options) === "off" ? resolved : null;
+}
 export function removeGitHookForRepo(context) {
     const lock = acquireLockSync(context.paths, SETUP_UNINSTALL_LOCK, { staleMs: SETUP_UNINSTALL_LOCK_STALE_MS });
     const removed = [];

package/dist/setup/plan.js

@@ -1,13 +1,17 @@
-import { accessSync, constants, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { accessSync, constants, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { basename, delimiter, dirname, join, resolve, sep } from "node:path";
 import { chmodSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { homedir } from "node:os";
 import { createTheme } from "../presentation/theme.js";
+import { reverseAgentHookEntry } from "../agents/registry.js";
 import { acquireLockSync, findStaleSessionsSync, preserveCorruptCleanupRegistrySync, resolveDgPaths, sweepStaleSessionsSync, CLEANUP_REGISTRY_LOCK } from "../state/index.js";
 import { currentNodeVersion, isSupportedNode } from "../runtime/node-version.js";
 import { dgVersion } from "../commands/version.js";
 import { compareVersions, readLatestVersion } from "../commands/update.js";
 import { AuthError, authStatus, displayTier, readAuthState } from "../auth/store.js";
 import { ConfigError, loadUserConfig } from "../config/settings.js";
+import { describeCooldownSettings } from "../policy/cooldown.js";
 import { resolveRealBinary } from "../launcher/resolve-real-binary.js";
 import { packageManagerNames } from "../launcher/classify.js";
 import { readServiceState } from "../service/state.js";
@@ -27,6 +31,7 @@ const LEGACY_RC_CANDIDATES = [".zshrc", ".bashrc", ".bash_profile", ".profile",
 const LEGACY_PYTHON_HOOK_PY = "dg_pip_hook.py";
 const LEGACY_PYTHON_HOOK_PTH = "dg_pip_hook.pth";
 const LEGACY_PYTHON_HOOK_MARKER = "Dependency Guardian pip-install interceptor";
+const LEGACY_PYTHON_HOOK_PTH_MARKER = "import dg_pip_hook";
 export const SETUP_UNINSTALL_LOCK = "setup-uninstall";
 export const SETUP_UNINSTALL_LOCK_STALE_MS = 30 * 60 * 1000;
 export const STALE_SESSION_OLDER_THAN_MS = 24 * 60 * 60 * 1000;
@@ -42,7 +47,7 @@ const DOCTOR_GROUP_BY_NAME = {
     "cleanup-registry-stale-entries": "setup",
     config: "setup",
     policy: "setup",
-    telemetry: "setup",
+    "script-gate": "setup",
     shims: "setup",
     "shell-rc": "setup",
     "python-hook-drift": "setup",
@@ -62,7 +67,6 @@ const DOCTOR_FIX_BY_NAME = {
     "cleanup-registry-stale-entries": "re-run dg setup to refresh",
     config: "fix or remove ~/.dg, then re-run dg setup",
     policy: "fix ~/.dg config",
-    telemetry: "fix ~/.dg config",
     shims: "dg setup",
     "shell-rc": "dg setup",
     "python-hook-drift": "dg uninstall, or re-run dg setup, to remove the stale pip hook",
@@ -154,7 +158,7 @@ export function applySetupPlan(plan, now = new Date()) {
         recursive: true,
         mode: 0o700
     });
-    writeFileSync(plan.rcPath, withRcBlock(readText(plan.rcPath), plan), "utf8");
+    writeRcFileAtomic(plan.rcPath, withRcBlock(readText(plan.rcPath), plan));
     entries.push(cleanupEntry("rc", plan.rcPath, "mode1", now, RC_SENTINEL));
     sweepLegacyPythonHooks(plan.paths.homeDir, [], []);
     const registry = withRegistryLock(plan.paths, () => {
@@ -211,6 +215,9 @@ export function uninstallSetup(options) {
             else if (entry.kind === "git-hook") {
                 reverseGitHookEntry(entry, removed, missing, warnings);
             }
+            else if (entry.kind === "agent-hook") {
+                reverseAgentHookEntry(entry, removed, missing, warnings);
+            }
         }
         sweepLegacyRcBlocks(paths.homeDir, removed, warnings);
         sweepLegacyPythonHooks(paths.homeDir, removed, warnings);
@@ -275,7 +282,7 @@ export function doctorReport(options = {}) {
     checks.push(configCheck(paths, env));
     checks.push(authCheck(env));
     checks.push(policyCheck(env));
-    checks.push(telemetryCheck(env));
+    checks.push(scriptGateCheck(env));
     const missingShims = SHIM_COMMANDS.filter((command) => !validShim(join(shimDir, command), command));
     checks.push({
         name: "shims",
@@ -565,6 +572,9 @@ function shellRcPath(homeDir, shell) {
     }
     return join(homeDir, ".zshrc");
 }
+export function tildifyPath(path, home = homedir()) {
+    return home && path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
 export function activationCommand(shell, rcDisplay) {
     if (shell === "fish") {
         return `source ${rcDisplay}`;
@@ -644,6 +654,26 @@ function fishRcBlock(shimDir) {
 function stripRcBlock(existing) {
     return stripRcBlockDetailed(existing).content;
 }
+function writeRcFileAtomic(rcPath, content) {
+    let target = rcPath;
+    let mode = 0o644;
+    try {
+        target = realpathSync(rcPath);
+        mode = statSync(target).mode & 0o7777;
+    }
+    catch {
+        // no existing file: write a fresh rc at the requested path
+    }
+    const tempPath = join(dirname(target), `.${basename(target)}.dg-${randomBytes(6).toString("hex")}.tmp`);
+    writeFileSync(tempPath, content, { encoding: "utf8", mode, flag: "wx" });
+    try {
+        renameSync(tempPath, target);
+    }
+    catch (error) {
+        rmSync(tempPath, { force: true });
+        throw error;
+    }
+}
 // An unterminated begin marker must never strip to EOF: only lines verifiably
 // written by dg are removed, so user content below a stale marker survives.
 function stripRcBlockDetailed(existing) {
@@ -693,7 +723,7 @@ function sweepLegacyRcBlocks(homeDir, removed, warnings) {
             continue;
         }
         try {
-            writeFileSync(rcPath, next, "utf8");
+            writeRcFileAtomic(rcPath, next);
             removed.push(`${rcPath} (legacy dg block)`);
         }
         catch (error) {
@@ -701,19 +731,23 @@ function sweepLegacyRcBlocks(homeDir, removed, warnings) {
         }
     }
 }
+function isLegacyPthHook(pthPath) {
+    const content = readText(pthPath);
+    return content.includes(LEGACY_PYTHON_HOOK_PTH_MARKER) || content.includes(LEGACY_PYTHON_HOOK_MARKER);
+}
 export function legacyPythonHookSites(homeDir) {
-    return candidateSitePackagesDirs(homeDir).filter((dir) => existsSync(join(dir, LEGACY_PYTHON_HOOK_PTH)) || readText(join(dir, LEGACY_PYTHON_HOOK_PY)).includes(LEGACY_PYTHON_HOOK_MARKER));
+    return candidateSitePackagesDirs(homeDir).filter((dir) => isLegacyPthHook(join(dir, LEGACY_PYTHON_HOOK_PTH)) || readText(join(dir, LEGACY_PYTHON_HOOK_PY)).includes(LEGACY_PYTHON_HOOK_MARKER));
 }
 export function sweepLegacyPythonHooks(homeDir, removed, warnings) {
     for (const dir of candidateSitePackagesDirs(homeDir)) {
         const pyPath = join(dir, LEGACY_PYTHON_HOOK_PY);
         const pthPath = join(dir, LEGACY_PYTHON_HOOK_PTH);
         const pyIsHook = readText(pyPath).includes(LEGACY_PYTHON_HOOK_MARKER);
-        const pthPresent = existsSync(pthPath);
-        if (!pyIsHook && !pthPresent) {
+        const pthIsHook = isLegacyPthHook(pthPath);
+        if (!pyIsHook && !pthIsHook) {
             continue;
         }
-        if (pthPresent) {
+        if (pthIsHook) {
             removePythonHookFile(pthPath, removed, warnings);
         }
         if (pyIsHook) {
@@ -870,7 +904,7 @@ function dgPathCheck(env) {
     };
 }
 function currentDgBinaryPath(env) {
-    const explicit = env.DG_TEST_CURRENT_DG_PATH;
+    const explicit = env.NODE_ENV === "test" ? env.DG_TEST_CURRENT_DG_PATH : undefined;
     if (explicit) {
         return explicit;
     }
@@ -1090,7 +1124,7 @@ function policyCheck(env) {
         return {
             name: "policy",
             status: "pass",
-            message: `Local policy mode ${config.policy.mode}; project allowlists trusted: ${config.policy.trustProjectAllowlists}`
+            message: `Local policy mode ${config.policy.mode}; project allowlists trusted: ${config.policy.trustProjectAllowlists}; release cooldown ${describeCooldownSettings(config, env)}`
         };
     }
     catch (error) {
@@ -1101,20 +1135,35 @@ function policyCheck(env) {
         };
     }
 }
-function telemetryCheck(env) {
+function scriptGateCheck(env) {
     try {
-        const config = loadUserConfig(env);
+        const mode = loadUserConfig(env).scriptGate.mode;
+        if (mode === "off") {
+            return {
+                name: "script-gate",
+                status: "pass",
+                message: "Install-script gate is off; protected installs do not report script-running packages"
+            };
+        }
+        if (mode === "enforce") {
+            return {
+                name: "script-gate",
+                status: "warn",
+                message: "scriptGate.mode is enforce, but this dg release observes only — installs report script-running packages without blocking",
+                fix: "enforcement ships in an upcoming release; dg config set scriptGate.mode observe clears this warning"
+            };
+        }
         return {
-            name: "telemetry",
+            name: "script-gate",
             status: "pass",
-            message: config.telemetry.enabled ? "Telemetry is enabled with minimized event fields" : "Telemetry is disabled"
+            message: "Install-script gate observes: protected npm/yarn installs report packages that ran install scripts (pnpm blocks them natively)"
         };
     }
     catch (error) {
         return {
-            name: "telemetry",
+            name: "script-gate",
             status: "fail",
-            message: error instanceof ConfigError ? error.message : "Unable to read telemetry config"
+            message: error instanceof ConfigError ? error.message : "Unable to read script gate config"
         };
     }
 }
@@ -1123,12 +1172,19 @@ export function writeRegistry(paths, registry) {
         recursive: true,
         mode: 0o700
     });
-    const tempPath = `${paths.cleanupRegistryPath}.${process.pid}.tmp`;
+    const tempPath = `${paths.cleanupRegistryPath}.${randomBytes(6).toString("hex")}.tmp`;
     writeFileSync(tempPath, `${JSON.stringify(registry, null, 2)}\n`, {
         encoding: "utf8",
-        mode: 0o600
+        mode: 0o600,
+        flag: "wx"
     });
-    renameSync(tempPath, paths.cleanupRegistryPath);
+    try {
+        renameSync(tempPath, paths.cleanupRegistryPath);
+    }
+    catch (error) {
+        rmSync(tempPath, { force: true });
+        throw error;
+    }
 }
 function withRegistryLock(paths, action) {
     const lock = acquireLockSync(paths, CLEANUP_REGISTRY_LOCK, {
@@ -1169,7 +1225,13 @@ function removeRcBlock(entry, removed, missing, warnings) {
         return;
     }
     const stripped = stripRcBlockDetailed(existing);
-    writeFileSync(entry.path, stripped.content, "utf8");
+    try {
+        writeRcFileAtomic(entry.path, stripped.content);
+    }
+    catch (error) {
+        warnings.push(`could not rewrite shell rc ${entry.path}: ${error instanceof Error ? error.message : "write error"}`);
+        return;
+    }
     if (stripped.repairedLines.length > 0) {
         warnings.push(`repaired an unterminated dg block in ${entry.path}: removed only dg-written lines (${stripped.repairedLines.join(", ")})`);
     }
@@ -1179,28 +1241,35 @@ function removeRcBlock(entry, removed, missing, warnings) {
 // a one-line notice and lets the commit (and any chained hook) proceed instead
 // of blocking every commit with exit 127.
 export function guardHookScript(dgPath, chainedOriginal) {
+    const dg = escapeDoubleQuotedSh(dgPath);
     const lines = [
         "#!/bin/sh",
         `# ${GUARD_HOOK_SENTINEL}`,
-        `if command -v "${dgPath}" >/dev/null 2>&1; then`,
-        `  "${dgPath}" scan --staged --hook || exit $?`,
+        `if command -v "${dg}" >/dev/null 2>&1; then`,
+        `  "${dg}" scan --staged --hook || exit $?`,
         "else",
-        `  echo "dg: pre-commit scan skipped (dg not runnable at ${dgPath}); commit allowed" >&2`,
+        `  echo "dg: pre-commit scan skipped (dg not runnable at ${dg}); commit allowed" >&2`,
         "fi"
     ];
     if (chainedOriginal) {
-        lines.push(`[ -x "${chainedOriginal}" ] && exec "${chainedOriginal}" "$@"`);
+        const chained = escapeDoubleQuotedSh(chainedOriginal);
+        lines.push(`[ -x "${chained}" ] && exec "${chained}" "$@"`);
     }
     lines.push("exit 0");
     return `${lines.join("\n")}\n`;
 }
+function unescapeDoubleQuotedSh(value) {
+    return value.replace(/\\([\\"$`])/g, "$1");
+}
 export function chainedHookOriginal(content) {
-    return content.match(/^\[ -x "(.+)" \] && exec "\1" "\$@"$/m)?.[1] ?? null;
+    const matched = content.match(/^\[ -x "(.+)" \] && exec "\1" "\$@"$/m)?.[1];
+    return matched ? unescapeDoubleQuotedSh(matched) : null;
 }
 export function guardHookDgPath(content) {
-    return (content.match(/^if command -v "(.+)" >\/dev\/null 2>&1; then$/m)?.[1] ??
+    const matched = content.match(/^if command -v "(.+)" >\/dev\/null 2>&1; then$/m)?.[1] ??
         content.match(/^"(.+)" scan --staged --hook/m)?.[1] ??
-        null);
+        null;
+    return matched ? unescapeDoubleQuotedSh(matched) : null;
 }
 function commitGuardCheck(registry, env) {
     const hooks = registry.entries.filter((entry) => entry.owner === "dg" && entry.kind === "git-hook");