@guilz-dev/belay 0.9.3 → 0.10.0

package/dist/cli.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import process from 'node:process';
 import { CLI_COMMAND } from './branding.js';
+import { issuePendingApprovalToken } from './commands/approval-token.js';
 import { approvePending } from './commands/approve.js';
 import { auditProject, formatAuditReport } from './commands/audit.js';
 import { doctorProject, formatDoctorReport } from './commands/doctor.js';
-import { dogfoodProject, formatDogfoodResult } from './commands/dogfood.js';
+import { checkDogfoodProject, dogfoodProject, formatDogfoodCheckResult, formatDogfoodResult, } from './commands/dogfood.js';
 import { explainCommand, formatExplainReport } from './commands/explain.js';
 import { formatHarvestReport, harvestApplyProject, harvestListProject } from './commands/harvest.js';
 import { formatMetricsReport, metricsProject } from './commands/metrics.js';
@@ -51,6 +52,13 @@ function parseArgs(argv) {
             options.force = true;
             continue;
         }
+        if (token === '--check') {
+            if (command !== 'dogfood') {
+                throw new Error('--check is only valid for dogfood.');
+            }
+            options.dogfoodCheck = true;
+            continue;
+        }
         if (token === '--adapter') {
             const next = rest[index + 1];
             if (!next || !['cursor', 'claude', 'codex'].includes(next)) {
@@ -472,12 +480,13 @@ function parseArgs(argv) {
                 token === 'get' ||
                 token === 'set' ||
                 token === 'unset' ||
+                token === 'trust' ||
                 token === 'credential' ||
                 token === 'judge') {
                 options.configSubcommand = token;
                 continue;
             }
-            throw new Error('config requires subcommand: list, get, set, unset, credential, or judge');
+            throw new Error('config requires subcommand: list, get, set, unset, trust, credential, or judge');
         }
         if (command === 'config' &&
             options.configSubcommand === 'credential' &&
@@ -519,7 +528,8 @@ function parseArgs(argv) {
             options.judgeUseProvider = token;
             continue;
         }
-        if ((command === 'revoke' || command === 'approve') && !options.approvalId) {
+        if ((command === 'revoke' || command === 'approve' || command === 'approval-token') &&
+            !options.approvalId) {
             options.approvalId = token;
             continue;
         }
@@ -534,10 +544,11 @@ function printHelp() {
 Usage:
   ${c} init [--target <dir>] [--adapter cursor|claude|codex] [--scope project|global] [--preset strict|standard|audit-first|l1-full-recommended] [--judge-profile local-ollama|cursor|claude|codex] [--judge-provider ollama|openai-compatible] [--judge-model <id>] [--judge-endpoint <url>] [--accept-cloud-judge] [--migrate-judge-default] [--with-skill] [--dogfood]
   ${c} config [--target <dir>] [--json]
-  ${c} config list|get|set|unset|judge [--target <dir>] [--json]
+  ${c} config list|get|set|unset|trust|judge [--target <dir>] [--json]
   ${c} config get <judge.path> [--target <dir>] [--json]
   ${c} config set <judge.path> <value> [--target <dir>]
   ${c} config unset <judge.path> [--target <dir>]
+  ${c} config trust [--target <dir>]
   ${c} config credential mode <project|apiKey> [--target <dir>]
   ${c} config credential set [--key-stdin] [--key-env <NAME>] [--target <dir>]
   ${c} config credential clear [--target <dir>]
@@ -547,6 +558,7 @@ Usage:
   ${c} uninstall [--target <dir>] [--adapter cursor] [--scope project|global]
   ${c} where [--target <dir>] [--adapter cursor|claude|codex] [--scope project|global] [--json]
   ${c} dogfood [--target <dir>] [--adapter cursor|claude|codex] [--enforce] [--force]
+  ${c} dogfood --check --since <iso> [--target <dir>] [--adapter cursor|claude|codex] [--json]
   ${c} doctor [--target <dir>] [--adapter cursor|claude|codex] [--json] [--fix] [--dry-run]
   ${c} metrics [--target <dir>] [--json]
   ${c} quality [--target <dir>] [--corpus <path>] [--json]
@@ -568,6 +580,7 @@ Usage:
   ${c} judge use <ollama|codex|claude|cursor> [--model <id>] [--endpoint <url>] [--timeout <ms>] [--accept-cloud] [--cloud-consent-approval-id <id>] [--credential project|apiKey] [--key-stdin] [--key-env <NAME>]
   ${c} judge consent <ollama|codex|claude|cursor> [--endpoint <url>]
   ${c} approve <approval-id> [--replay] [--scope once|domain|path|workspace-root] [--path <path>] [--token <signed-token>] [--target <dir>]
+  ${c} approval-token <approval-id> [--target <dir>] [--json]
   ${c} revoke <approval-id> [--target <dir>]
   ${c} standing-allow revoke --fingerprint <fp> [--kind shell|tool|subagent] [--target <dir>]
   ${c} harvest list [--target <dir>] [--since <iso>] [--until <iso>] [--json]
@@ -615,6 +628,30 @@ async function main() {
             return;
         }
         if (command === 'dogfood') {
+            if (options.dogfoodCheck) {
+                if (options.enforce) {
+                    throw new Error('--check conflicts with --enforce.');
+                }
+                if (options.force) {
+                    throw new Error('--check conflicts with --force.');
+                }
+                if (!options.since) {
+                    throw new Error('--check requires --since <iso>.');
+                }
+                const report = await checkDogfoodProject({
+                    targetDir: options.targetDir,
+                    adapter: options.adapter,
+                    since: options.since,
+                });
+                if (options.json) {
+                    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+                }
+                else {
+                    process.stdout.write(formatDogfoodCheckResult(report));
+                }
+                process.exitCode = report.ok ? 0 : 1;
+                return;
+            }
             const result = await dogfoodProject({
                 targetDir: options.targetDir,
                 enforce: options.enforce,
@@ -1031,6 +1068,18 @@ async function main() {
             process.exitCode = result.ok ? 0 : 1;
             return;
         }
+        if (command === 'approval-token') {
+            if (!options.approvalId) {
+                throw new Error('approval-token requires an approval ID.');
+            }
+            const result = await issuePendingApprovalToken({
+                targetDir: options.targetDir,
+                approvalId: options.approvalId,
+            });
+            process.stdout.write(options.json ? `${JSON.stringify(result, null, 2)}\n` : `${result.message}\n`);
+            process.exitCode = result.ok ? 0 : 1;
+            return;
+        }
         if (command === 'revoke') {
             if (!options.approvalId) {
                 throw new Error('revoke requires an approval ID.');

package/dist/commands/approval-token.d.ts

@@ -0,0 +1,10 @@
+export interface IssuePendingApprovalTokenOptions {
+    targetDir?: string;
+    approvalId: string;
+}
+export interface IssuePendingApprovalTokenResult {
+    ok: boolean;
+    message: string;
+    token?: string;
+}
+export declare function issuePendingApprovalToken(options: IssuePendingApprovalTokenOptions): Promise<IssuePendingApprovalTokenResult>;

package/dist/commands/approval-token.js

@@ -0,0 +1,26 @@
+import path from 'node:path';
+import { loadApprovalState, loadConfigFile } from '../config-io.js';
+import { isExpired } from '../core/approval.js';
+import { issueApprovalToken } from '../core/approval-token.js';
+import { configuredControlPlaneDir } from '../core/config.js';
+import { canonicalPath } from '../core/path-utils.js';
+export async function issuePendingApprovalToken(options) {
+    const repoRoot = path.resolve(options.targetDir ?? process.cwd());
+    const config = await loadConfigFile(repoRoot);
+    const pending = await loadApprovalState(repoRoot, 'pending-approvals.json', config);
+    const approval = pending.approvals.find((entry) => entry.approvalId === options.approvalId);
+    if (!approval || isExpired(approval)) {
+        return { ok: false, message: `Pending approval not found: ${options.approvalId}` };
+    }
+    if (canonicalPath(approval.repoRoot) !== canonicalPath(repoRoot)) {
+        return { ok: false, message: `Approval repository does not match: ${options.approvalId}` };
+    }
+    const token = await issueApprovalToken({
+        approvalId: approval.approvalId,
+        fingerprint: approval.fingerprint,
+        repoRoot: approval.repoRoot,
+        issuedAt: approval.createdAt,
+        expiresAt: approval.expiresAt,
+    }, configuredControlPlaneDir(config));
+    return { ok: true, token, message: token };
+}

package/dist/commands/audit.d.ts

@@ -1,4 +1,5 @@
 import type { AuditRecord } from '../core/audit-types.js';
+import type { AdapterName } from '../types.js';
 export type AuditSubcommand = 'query' | 'summarize' | 'replay';
 export interface AuditOptions {
     targetDir?: string;
@@ -18,7 +19,7 @@ export interface AuditOptions {
     limit?: number;
     configPath?: string;
 }
-export declare function loadAuditRecords(repoRoot: string): Promise<AuditRecord[]>;
+export declare function loadAuditRecords(repoRoot: string, adapter?: AdapterName): Promise<AuditRecord[]>;
 export declare function auditProject(options: AuditOptions): Promise<{
     subcommand: string;
     records: AuditRecord[];

package/dist/commands/audit.js

@@ -7,8 +7,8 @@ import { parseAuditNdjson, toAuditRecord } from '../core/audit-metrics.js';
 import { buildApprovalRoundTrips, filterAuditRecords, summarizeRoundTrips, } from '../core/audit-query.js';
 import { mergeConfig } from '../core/config.js';
 import { diffReclassification } from '../core/reclassify.js';
-export async function loadAuditRecords(repoRoot) {
-    const config = await loadConfigFile(repoRoot);
+export async function loadAuditRecords(repoRoot, adapter) {
+    const config = await loadConfigFile(repoRoot, adapter);
     const auditLogPath = path.join(repoRoot, config.audit.logPath);
     let raw = '';
     try {

package/dist/commands/config.d.ts

@@ -1,7 +1,7 @@
 import { type JudgeProviderId } from '../core/verdict/judge-catalog.js';
 import type { AdapterName, InitOptions } from '../types.js';
 import { type SelectOptions } from './tui.js';
-export declare const BELAY_CONFIG_SUBCOMMANDS: readonly ["list", "get", "set", "unset", "credential", "judge"];
+export declare const BELAY_CONFIG_SUBCOMMANDS: readonly ["list", "get", "set", "unset", "trust", "credential", "judge"];
 export type BelayConfigSubcommand = (typeof BELAY_CONFIG_SUBCOMMANDS)[number];
 export interface BelayConfigOptions {
     targetDir?: string;

package/dist/commands/config.js

@@ -1,7 +1,8 @@
+import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { stdin as input, stdout as output } from 'node:process';
 import readline from 'node:readline/promises';
-import { loadConfigFile, repoLocalStateDirFor, resolveAdapterName, writeConfigFile, } from '../config-io.js';
+import { configPathFor, detectAdapterName, loadConfigFile, repoLocalStateDirFor, resolveAdapterName, writeTrustedConfigFile, } from '../config-io.js';
 import { appendCliAuditEvent } from '../core/audit-io.js';
 import { belayStateDir, normalizeJudgeConfig } from '../core/config.js';
 import { clearJudgeCredentialStore, writeJudgeCredentialStore } from '../core/credential-store.js';
@@ -9,6 +10,7 @@ import { refreshIntegrityIfPinned } from '../core/integrity.js';
 import { defaultJudgeProviderForAdapter, hasValidCloudConsent, isCloudJudgeConfig, resolveJudgeUsePatch, } from '../core/judge-config.js';
 import { rejectDeprecatedJudgeModelAuto } from '../core/judge-model-policy.js';
 import { detectJudgeRuntimeCapabilities, resolveJudgeTransport, } from '../core/judge-runtime-detection.js';
+import { trustRepoConfig } from '../core/repo-config-trust.js';
 import { getJudgeProviderSpec, isJudgeProviderId, JUDGE_PROVIDER_IDS, normalizeLegacyProviderId, } from '../core/verdict/judge-catalog.js';
 import { normalizeJudgeRuntimeConfig } from '../core/verdict/judge-runtime-config.js';
 import { initProject } from '../installer.js';
@@ -21,6 +23,7 @@ export const BELAY_CONFIG_SUBCOMMANDS = [
     'get',
     'set',
     'unset',
+    'trust',
     'credential',
     'judge',
 ];
@@ -125,7 +128,7 @@ function warnCloudConsentIfNeeded(judge) {
 }
 async function persistJudge(repoRoot, config, judge, adapter) {
     const updated = { ...config, judge: normalizeJudgeConfig(judge) };
-    await writeConfigFile(repoRoot, updated, adapter);
+    await writeTrustedConfigFile(repoRoot, updated, adapter);
     await refreshIntegrityIfPinned(repoRoot, updated);
     return updated;
 }
@@ -651,6 +654,29 @@ export async function runBelayConfig(options = {}) {
         return runBelayConfigInteractive({ targetDir: options.targetDir });
     }
     const repoRoot = path.resolve(options.targetDir ?? process.cwd());
+    if (options.subcommand === 'trust') {
+        const adapter = detectAdapterName(repoRoot);
+        const configPath = configPathFor(repoRoot, adapter);
+        let rawConfig;
+        try {
+            rawConfig = JSON.parse(await readFile(configPath, 'utf8'));
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT') {
+                throw new Error(`Missing repository config: ${configPath}`);
+            }
+            throw new Error(`Repository config is malformed JSON: ${configPath}`);
+        }
+        const record = await trustRepoConfig(repoRoot, adapter, rawConfig);
+        const merged = await loadConfigFile(repoRoot, adapter);
+        await refreshIntegrityIfPinned(repoRoot, merged);
+        return [
+            'Repository config trusted:',
+            JSON.stringify(rawConfig, null, 2),
+            `Trusted fingerprint: ${record.repoConfigFingerprint}`,
+            `Repository: ${record.repoRoot}`,
+        ].join('\n');
+    }
     const config = await loadConfigFile(repoRoot);
     if (options.subcommand === 'list') {
         const entries = listJudgeFields(config.judge);

package/dist/commands/doctor.js

@@ -1,25 +1,29 @@
-import { existsSync } from 'node:fs';
+import { existsSync, realpathSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { getClaudeManagedHookEntries } from '../adapters/claude/hooks.js';
-import { getCodexManagedHookEntries } from '../adapters/codex/hooks.js';
-import { hasDuplicateCursorShellGates } from '../adapters/cursor/hooks.js';
+import { codexHooksTomlIncludesCommand, getCodexManagedHookEntries, } from '../adapters/codex/hooks.js';
+import { hasCurrentCursorDispatcherGeneration } from '../adapters/cursor/dispatcher-generation.js';
+import { hasLegacyCursorDoubleShellGates, hasManagedCursorHookEntries, } from '../adapters/cursor/hooks.js';
 import { getAdapterLayout } from '../adapters/layouts/index.js';
 import { protectedArtifactRoots } from '../adapters/layouts/protected-paths.js';
 import { resolveScopedPaths } from '../adapters/layouts/scope.js';
 import { cleanupOrphanApprovalState } from '../cleanup-orphans.js';
-import { approvedApprovalsPath, belayStateDir, detectAdapterName, loadLayeredConfig, pendingApprovalsPath, repoLocalStateDirFor, writeConfigFile, } from '../config-io.js';
+import { approvedApprovalsPath, belayStateDir, detectAdapterName, loadLayeredConfig, pendingApprovalsPath, repoLocalStateDirFor, writeTrustedConfigFile, } from '../config-io.js';
 import { approvalSigningKeyPath } from '../core/approval-token.js';
 import { auditRecordHasLegacyCorrelationPlaceholders } from '../core/audit-legacy-archive.js';
 import { detectFenceDrift, summarizeAuditVisibility } from '../core/audit-summary.js';
 import { inspectBoundaryAttestationFile } from '../core/capability/boundary-attestation-sign.js';
 import { boundaryAttestationPath, boundarySessionStatus, } from '../core/capability/boundary-session.js';
 import { configuredControlPlaneDir, defaultControlPlaneDir, hasForbiddenShellOverrideLists, stripForbiddenShellOverrideLists, } from '../core/config.js';
-import { verifyIntegrityManifest } from '../core/integrity.js';
+import { detectUndogfoodedLinkedWorktrees } from '../core/dogfood-environment.js';
+import { runtimeIntegrityFiles, verifyIntegrityManifest } from '../core/integrity.js';
 import { diagnoseJudge, stopJudgeSessionBrokers } from '../core/judge-doctor.js';
 import { resolveJudgeTransport } from '../core/judge-runtime-detection.js';
+import { notificationConfigIssues } from '../core/notify.js';
 import { listRecoveryCheckpoints } from '../core/recovery/checkpoint.js';
 import { recoveryApprovalSetupNotes, recoveryNotificationConfigured, recoveryNotificationSetupWarning, summarizeRecoveryCheckpointDiagnostics, } from '../core/recovery/operator-guidance.js';
+import { inspectRepoConfigTrust } from '../core/repo-config-trust.js';
 import { probeFileCheckpointBackend } from '../core/transactional/backend-selector.js';
 import { fileCheckpointIsolationReason } from '../core/transactional/file-checkpoint-isolation.js';
 import { probeFileCloneStrategy } from '../core/transactional/file-clone.js';
@@ -52,6 +56,61 @@ function hasCursorGlobalWorkspaceResolver(runtimeSource) {
         runtimeSource.includes('working_directory') &&
         runtimeSource.includes('tool_input'));
 }
+const CURSOR_HOOK_SHIMS = [
+    'belay-before-submit.mjs',
+    'belay-shell-gate.mjs',
+    'belay-tool-gate.mjs',
+    'belay-audit.mjs',
+];
+function runnerFileName(adapterName, platform) {
+    if (platform !== 'win32') {
+        return 'belay-runner';
+    }
+    return adapterName === 'cursor' ? 'belay-runner.ps1' : 'belay-runner.cmd';
+}
+async function cursorOriginIssues(hooksDir, installScope, repoRoot) {
+    const canonicalRepoRoot = realpathSync(repoRoot);
+    const issues = [];
+    for (const fileName of CURSOR_HOOK_SHIMS) {
+        const shimPath = path.join(hooksDir, fileName);
+        if (!existsSync(shimPath)) {
+            continue;
+        }
+        let source;
+        try {
+            source = await readFile(shimPath, 'utf8');
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            issues.push(`Unable to inspect Cursor hook shim for intended ${installScope} owner: ${shimPath}: ${detail}. Run belay upgrade --scope ${installScope}.`);
+            continue;
+        }
+        if (!source.includes("from '../belay/runtime/dispatcher.mjs'")) {
+            issues.push(`Cursor router generation mismatch for intended ${installScope} owner: ${shimPath}. Run belay upgrade --scope ${installScope}.`);
+            continue;
+        }
+        const originMatch = source.match(/origin:\s*(\{[^\n]+\})/);
+        let originMatches = false;
+        if (originMatch?.[1]) {
+            try {
+                const origin = JSON.parse(originMatch[1]);
+                originMatches =
+                    installScope === 'global'
+                        ? origin.scope === 'global'
+                        : origin.scope === 'project' &&
+                            typeof origin.repoRoot === 'string' &&
+                            realpathSync(origin.repoRoot) === canonicalRepoRoot;
+            }
+            catch {
+                originMatches = false;
+            }
+        }
+        if (!originMatches) {
+            issues.push(`Cursor hook origin mismatch for intended ${installScope} owner: ${shimPath}. Run belay upgrade --scope ${installScope}.`);
+        }
+    }
+    return issues;
+}
 export async function doctorProject(options = {}) {
     const repoRoot = path.resolve(options.targetDir ?? process.cwd());
     const issues = [];
@@ -76,12 +135,17 @@ export async function doctorProject(options = {}) {
             configPath = activeLayout.configPath(repoRoot);
             hooksPath = activeLayout.hooksSettingsPath(repoRoot);
             corePath = path.join(activeLayout.runtimeDir(repoRoot), 'core.mjs');
+            const trust = await inspectRepoConfigTrust(repoRoot, adapterName, rawConfig);
+            if (!trust.trusted) {
+                issues.push(`Repository config is not trusted (${trust.reason}) at ${trust.recordPath}. Review it, then run belay config trust.`);
+            }
             if (rawConfig.version === undefined) {
                 warnings.push('Config is missing "version". Set "version": 3 explicitly to avoid ambiguous migration.');
             }
             const layered = await loadLayeredConfig(repoRoot, adapterName);
             loadedConfig = layered.config;
             configProvenance = layered.provenance;
+            issues.push(...notificationConfigIssues(loadedConfig.notifications, repoRoot));
             for (const entry of layered.provenance) {
                 notes.push(`Config layer [${entry.source}]: ${entry.path}`);
             }
@@ -145,9 +209,9 @@ export async function doctorProject(options = {}) {
             }
             if (loadedConfig.controlPlane.integrity === 'hash-pinned') {
                 notes.push('Integrity: hash-pinned (verify with belay upgrade after runtime changes).');
-                const integrity = await verifyIntegrityManifest(repoRoot, activeLayout);
+                const integrity = await verifyIntegrityManifest(repoRoot, activeLayout, runtimeIntegrityFiles(activeLayout, scopedPaths));
                 if (!integrity.ok) {
-                    issues.push(`Integrity verification failed: ${integrity.mismatches.slice(0, 3).join(', ')}`);
+                    issues.push(`Integrity verification failed: ${integrity.mismatches.join(', ')}`);
                 }
             }
         }
@@ -163,14 +227,16 @@ export async function doctorProject(options = {}) {
     const repoLocalDir = loadedConfig
         ? repoLocalStateDirFor(repoRoot, loadedConfig)
         : activeLayout.repoLocalStateDir(repoRoot);
-    const requiredPaths = [
-        path.join(hooksDir, 'belay-runner'),
-        path.join(hooksDir, 'belay-runner.cmd'),
+    const routingOwnerPaths = [
+        path.join(hooksDir, runnerFileName(adapterName, process.platform)),
         path.join(hooksDir, 'belay-before-submit.mjs'),
         path.join(hooksDir, 'belay-shell-gate.mjs'),
         path.join(hooksDir, 'belay-tool-gate.mjs'),
         path.join(hooksDir, 'belay-audit.mjs'),
+        ...(adapterName === 'cursor' ? [path.join(scopedPaths.runtimeDir, 'dispatcher.mjs')] : []),
         corePath,
+    ];
+    const operationalPaths = [
         loadedConfig
             ? pendingApprovalsPath(repoRoot, loadedConfig)
             : path.join(repoLocalDir, 'pending-approvals.json'),
@@ -179,9 +245,67 @@ export async function doctorProject(options = {}) {
             : path.join(repoLocalDir, 'approved-approvals.json'),
         path.join(repoRoot, loadedConfig?.audit.logPath ?? activeLayout.defaultAuditLogPath(repoRoot)),
     ];
+    const requiredPaths = [...routingOwnerPaths, ...operationalPaths];
     for (const requiredPath of requiredPaths) {
         if (!existsSync(requiredPath)) {
             issues.push(`Missing generated file: ${requiredPath}`);
+            if (adapterName === 'cursor' && routingOwnerPaths.includes(requiredPath)) {
+                issues.push(`Cursor intended ${installScope} owner is incomplete: missing ${requiredPath}. Run belay upgrade --scope ${installScope}.`);
+            }
+        }
+    }
+    if (adapterName === 'cursor') {
+        issues.push(...(await cursorOriginIssues(hooksDir, installScope, repoRoot)));
+        const dispatcherPath = path.join(scopedPaths.runtimeDir, 'dispatcher.mjs');
+        if (existsSync(dispatcherPath) &&
+            !hasCurrentCursorDispatcherGeneration(await readFile(dispatcherPath, 'utf8'))) {
+            issues.push(`Cursor router generation mismatch for intended ${installScope} owner dispatcher: ${dispatcherPath}. Run belay upgrade --scope ${installScope}.`);
+        }
+        if (installScope === 'project') {
+            const globalPaths = resolveScopedPaths(activeLayout, 'global', repoRoot);
+            if (existsSync(globalPaths.hooksSettingsPath)) {
+                try {
+                    const { loadHooksFile } = await import('../installer.js');
+                    const globalHooks = await loadHooksFile(globalPaths.hooksSettingsPath);
+                    if (hasManagedCursorHookEntries(globalHooks, process.platform, globalPaths.hooksDir, repoRoot)) {
+                        const globalOwnerFiles = [
+                            path.join(globalPaths.hooksDir, runnerFileName('cursor', process.platform)),
+                            path.join(globalPaths.runtimeDir, 'core.mjs'),
+                            path.join(globalPaths.runtimeDir, 'dispatcher.mjs'),
+                            ...CURSOR_HOOK_SHIMS.map((fileName) => path.join(globalPaths.hooksDir, fileName)),
+                        ];
+                        const globalOriginProblems = await cursorOriginIssues(globalPaths.hooksDir, 'global', repoRoot);
+                        issues.push(...globalOriginProblems);
+                        const globalProblems = [
+                            ...globalOwnerFiles.filter((filePath) => !existsSync(filePath)),
+                            ...globalOriginProblems,
+                        ];
+                        const globalDispatcherPath = path.join(globalPaths.runtimeDir, 'dispatcher.mjs');
+                        if (existsSync(globalDispatcherPath)) {
+                            try {
+                                if (!hasCurrentCursorDispatcherGeneration(await readFile(globalDispatcherPath, 'utf8'))) {
+                                    globalProblems.push(globalDispatcherPath);
+                                }
+                            }
+                            catch (error) {
+                                const detail = error instanceof Error ? error.message : String(error);
+                                issues.push(`Unable to inspect shadowed global Cursor dispatcher at ${globalDispatcherPath}: ${detail}.`);
+                                globalProblems.push(globalDispatcherPath);
+                            }
+                        }
+                        if (globalProblems.length > 0) {
+                            issues.push('Global Cursor installation cannot yield to the project owner. Run belay upgrade from this project to refresh the global router.');
+                        }
+                        else {
+                            notes.push('Healthy global Cursor install is shadowed by this project owner and will return neutral for this repository.');
+                        }
+                    }
+                }
+                catch (error) {
+                    const detail = error instanceof Error ? error.message : String(error);
+                    issues.push(`Unable to inspect shadowed global Cursor hooks at ${globalPaths.hooksSettingsPath}: ${detail}.`);
+                }
+            }
         }
     }
     let hooksOk = true;
@@ -196,15 +320,17 @@ export async function doctorProject(options = {}) {
             const hooksFile = await loadHooksFile(hooksPath);
             for (const { event, definition } of managedEntries) {
                 const entries = hooksFile.hooks[event] ?? [];
-                const present = entries.some((entry) => entry.command === definition.command && entry.matcher === definition.matcher);
-                if (!present) {
+                const matchingEntry = entries.find((entry) => entry.command === definition.command && entry.matcher === definition.matcher);
+                if (!matchingEntry || matchingEntry.failClosed !== true) {
                     hooksOk = false;
                     const matcherSuffix = definition.matcher ? ` (matcher: ${definition.matcher})` : '';
-                    issues.push(`Missing managed hook for ${event}: ${definition.command}${matcherSuffix}`);
+                    issues.push(matchingEntry
+                        ? `Managed Cursor hook for ${event} must set failClosed: true: ${definition.command}${matcherSuffix}`
+                        : `Missing managed hook for ${event}: ${definition.command}${matcherSuffix}`);
                 }
             }
-            if (hasDuplicateCursorShellGates(hooksFile, process.platform, hooksDir, repoRoot)) {
-                warnings.push('Duplicate Cursor Shell preToolUse gates detected. Run belay upgrade to dedupe managed hooks.');
+            if (hasLegacyCursorDoubleShellGates(hooksFile, process.platform, hooksDir, repoRoot)) {
+                warnings.push('Legacy Cursor Shell preToolUse gate detected alongside beforeShellExecution. Run belay upgrade to remove the managed Shell matcher.');
             }
         }
         else if (adapterName === 'codex') {
@@ -212,7 +338,7 @@ export async function doctorProject(options = {}) {
             // are present in the rendered TOML block.
             const toml = await readFile(hooksPath, 'utf8');
             for (const { event, definition } of managedEntries) {
-                if (!toml.includes(definition.command)) {
+                if (!codexHooksTomlIncludesCommand(toml, definition.command)) {
                     hooksOk = false;
                     issues.push(`Missing Codex managed hook for ${event}: ${definition.command}`);
                 }
@@ -276,7 +402,7 @@ export async function doctorProject(options = {}) {
         if (hasForbiddenShellOverrideLists(loadedConfig)) {
             if (options.dryRun !== true) {
                 const stripped = stripForbiddenShellOverrideLists(loadedConfig);
-                await writeConfigFile(repoRoot, stripped, adapterName);
+                await writeTrustedConfigFile(repoRoot, stripped, adapterName);
                 loadedConfig = stripped;
                 notes.push('Removed forbidden legacy shell override lists (overrides.allow / overrides.external).');
                 for (let index = issues.length - 1; index >= 0; index -= 1) {
@@ -346,6 +472,12 @@ export async function doctorProject(options = {}) {
         };
         if (dogfood.active) {
             notes.push(`Dogfood active cohort: ${dogfood.gateEvents} gate events, ${dogfood.wouldBlockCount} would-block (${(dogfood.wouldBlockRate * 100).toFixed(1)}%); ${dogfood.excludedGateEvents} historical/mismatched event(s) excluded.`);
+            notes.push(`Host denied after Belay allow (cohort): ${auditVisibility.hostDeniedAfterAllowCount}.`);
+            warnings.push(...(await detectUndogfoodedLinkedWorktrees({
+                repoRoot,
+                adapterName,
+                layout: activeLayout,
+            })));
             if (dogfood.readyForEnforce) {
                 notes.push('Dogfood metrics suggest enforce mode is ready (belay dogfood --enforce).');
             }

package/dist/commands/dogfood-check.d.ts

@@ -0,0 +1,3 @@
+import type { DogfoodCheckOptions, DogfoodCheckResult } from '../types.js';
+export declare function checkDogfoodProject(options: DogfoodCheckOptions): Promise<DogfoodCheckResult>;
+export declare function formatDogfoodCheckResult(result: DogfoodCheckResult): string;