log-llm-config-staging 1.3.82 → 1.3.83

package/dist/compliance_prompt_gate.js

@@ -6,7 +6,8 @@
  * When autofix returns restart_commands, this process does not spawn them — the shell hook pipes
  * the same JSON line to execute_trusted_restarts (TS allowlist + spawn).
  */
-import { applyAutofixViolations, normalizeAgentToken, pruneSatisfiedOneTimeRemediations, runLocalRemediationComplianceCheck, } from './log_config_files/runtime/compliance_check.js';
+import { applyAutofixViolations, normalizeAgentToken, pruneSatisfiedOneTimeRemediations, reportPostRestartVerificationOutcomes, runLocalRemediationComplianceCheck, } from './log_config_files/runtime/compliance_check.js';
+import { isRemediationQuarantined } from './log_config_files/runtime/remediation_apply_tracking.js';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { getRemediationInstructionsPath, readRemediationInstructionsFile } from './log_config_files/runtime/management_storage.js';
 import { hookLogSessionBanner, hookRunLog, logRemediationApplyFailure } from './log_config_files/runtime/hook_logger.js';
@@ -179,6 +180,12 @@ export async function runCompliancePromptGate() {
         }
     }
     const status = runLocalRemediationComplianceCheck(agent);
+    // Always process pending post-restart rows (even when compliance is ok — apply may have stuck).
+    const postRestartVerify = reportPostRestartVerificationOutcomes(status.violations);
+    if (postRestartVerify.outcomes.length > 0) {
+        await Promise.allSettled(postRestartVerify.reportPromises);
+        hookRunLog(`compliance_prompt_gate: post_restart_verification count=${postRestartVerify.outcomes.length} quarantined=${postRestartVerify.outcomes.filter((o) => o.status === 'quarantined').length}`);
+    }
     // Secondary-satisfied: primary checks failed but settings.json (or equiv) has the fix.
     // Upload those files fire-and-forget so the backend can resolve the finding immediately.
     for (const e of status.secondarySatisfied ?? []) {
@@ -198,7 +205,17 @@ export async function runCompliancePromptGate() {
             printAllowWithAdvisory(ide, advisory);
             return;
         }
-        const { fixed, appliedViolations = [], restartCommands, failedViolations, reportPromises, deferredSqlitePending, } = applyAutofixViolations(status.violations, agent);
+        const actionableViolations = status.violations.filter((v) => !isRemediationQuarantined(v.uuid));
+        if (actionableViolations.length === 0 && status.violations.length > 0) {
+            hookRunLog(`compliance_prompt_gate: all ${status.violations.length} violation(s) quarantined — allowing prompt silently (backend notified on quarantine)`);
+            logRemediationApplyFailure('prompt_gate_quarantined_silent_allow', {
+                reason: 'all violations quarantined; no dialog — enforcement paused on this machine',
+                quarantined_count: status.violations.length,
+            });
+            printAllow(ide);
+            return;
+        }
+        const { fixed, appliedViolations = [], restartCommands, failedViolations, reportPromises, deferredSqlitePending, } = applyAutofixViolations(actionableViolations, agent);
         hookRunLog(`compliance_prompt_gate: autofix result ide=${ide} fixed=${fixed} applied=${appliedViolations.length} failed=${failedViolations.length} restart_commands=${restartCommands.length} deferred_sqlite_pending=${deferredSqlitePending}`);
         if (fixed > 0) {
             // Wait for all server reports before exiting so the POST lands.

package/dist/log_config_files/readers/composer_shadow_merge.js

@@ -0,0 +1,67 @@
+import { CURSOR_SHADOW_KEYS_NESTED_WINS, coalesceCursorEnabledShadowValue, stripShadowKeysFromReactiveBlobUpload, } from './cursor_shadow_merge_policy.js';
+const CURSOR_SHADOW_KEYS_MERGE_ENABLED_OR = new Set([
+    'isWebSearchToolEnabled',
+    'isWebSearchToolEnabled2',
+]);
+/**
+ * Collect include_keys from composer_with_include read steps (backend-driven list).
+ */
+export function shadowKeysFromReadQueries(readQueries) {
+    const keys = new Set();
+    for (const step of readQueries ?? []) {
+        if (step.value_kind === 'composer_with_include' && step.include_keys?.length) {
+            for (const k of step.include_keys) {
+                keys.add(k);
+            }
+        }
+    }
+    return [...keys];
+}
+/**
+ * Resolve one shadow key from reactive blob root + nested composerState (matches scan_targets).
+ */
+export function mergeCursorShadowKeyValue(key, root, nested) {
+    const rootVal = Object.prototype.hasOwnProperty.call(root, key) ? root[key] : undefined;
+    const nestedVal = nested && Object.prototype.hasOwnProperty.call(nested, key) ? nested[key] : undefined;
+    if (CURSOR_SHADOW_KEYS_NESTED_WINS.has(key)) {
+        if (nestedVal !== undefined)
+            return nestedVal;
+        if (rootVal !== undefined)
+            return rootVal;
+        return undefined;
+    }
+    if (CURSOR_SHADOW_KEYS_MERGE_ENABLED_OR.has(key)) {
+        return coalesceCursorEnabledShadowValue(rootVal, nestedVal);
+    }
+    if (rootVal !== undefined)
+        return rootVal;
+    return nestedVal;
+}
+/**
+ * Merge shadow keys from the reactive blob into nested composerState (canonical for policy).
+ * Matches policy_engine.scan_targets; strips duplicate top-level keys from the upload shape.
+ */
+export function mergeShadowKeysIntoComposerState(stateData, shadowKeys) {
+    if (!shadowKeys.length)
+        return;
+    const hasNested = stateData.composerState &&
+        typeof stateData.composerState === 'object' &&
+        !Array.isArray(stateData.composerState);
+    const hasRootKey = shadowKeys.some((k) => Object.prototype.hasOwnProperty.call(stateData, k));
+    if (!hasNested && !hasRootKey)
+        return;
+    let cs = stateData.composerState;
+    if (!hasNested) {
+        cs = {};
+        stateData.composerState = cs;
+    }
+    const composerState = cs;
+    const root = stateData;
+    for (const key of shadowKeys) {
+        const merged = mergeCursorShadowKeyValue(key, root, composerState);
+        if (merged !== undefined) {
+            composerState[key] = merged;
+        }
+    }
+    stripShadowKeysFromReactiveBlobUpload(stateData);
+}

package/dist/log_config_files/readers/cursor_shadow_merge_policy.js

@@ -0,0 +1,46 @@
+/**
+ * Keep in sync with file_path_registry/cursor_composer_shadow_keys.py
+ * (CURSOR_REACTIVE_BLOB_SHADOW_KEYS + merge sets).
+ */
+/** Keys Cursor duplicates on the reactive blob root and inside composerState. */
+export const CURSOR_COMPOSER_SHADOW_KEYS = [
+    'lastBrowserConnectionMode',
+    'playwrightProtection',
+    'isWebSearchToolEnabled',
+    'isWebSearchToolEnabled2',
+    'isWebSearchToolEnabled3',
+    'isWebFetchToolEnabled',
+    'autoAcceptWebSearchTool',
+];
+/** Cursor Settings UI writes these on nested composerState; blob root copies are often stale. */
+export const CURSOR_SHADOW_KEYS_NESTED_WINS = new Set([
+    'playwrightProtection',
+    'isWebFetchToolEnabled',
+    'isWebSearchToolEnabled3',
+    'autoAcceptWebSearchTool',
+]);
+export function cursorShadowValueIsEnabled(value) {
+    return (value === true ||
+        value === 1 ||
+        (typeof value === 'string' && ['true', '1', 'yes'].includes(value.toLowerCase())));
+}
+/** Prefer nested when enabled (web search / auto-accept); else root. */
+export function coalesceCursorEnabledShadowValue(root, nested) {
+    if (cursorShadowValueIsEnabled(nested))
+        return nested;
+    if (cursorShadowValueIsEnabled(root))
+        return root;
+    if (root !== undefined && root !== null)
+        return root;
+    return nested;
+}
+/**
+ * After merge, policy and uploads use composerState.<key> only — drop stale blob-root copies.
+ */
+export function stripShadowKeysFromReactiveBlobUpload(stateData) {
+    if (!('composerState' in stateData))
+        return;
+    for (const key of CURSOR_COMPOSER_SHADOW_KEYS) {
+        delete stateData[key];
+    }
+}

package/dist/log_config_files/readers/vscdb_config_builder.js

@@ -65,7 +65,9 @@ function buildRawContent(state, stateKey, value, includeKeys, ts) {
     else {
         raw[stateKey] = value;
     }
-    if (includeKeys?.length) {
+    // Shadow keys are merged into composerState during readVSCDBState; do not copy stale blob-root
+    // copies onto the upload payload (policy paths are composerState.<key> only).
+    if (includeKeys?.length && stateKey !== 'composerState') {
         for (const k of includeKeys) {
             if (k in state && state[k] !== undefined)
                 raw[k] = state[k];

package/dist/log_config_files/readers/vscdb_reactive_storage.js

@@ -0,0 +1,62 @@
+import { existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { readFileCollectionVscdbContract } from '../runtime/management_storage.js';
+import { resolveSqlite3Binary } from '../runtime/sqlite_binary.js';
+import { CURSOR_COMPOSER_SHADOW_KEYS } from './cursor_shadow_merge_policy.js';
+/** Suffix shared by Cursor reactive-storage ItemTable keys (see file_path_registry cursor agent). */
+export const REACTIVE_STORAGE_ITEM_KEY_SUFFIX = 'reactiveStorageServiceImpl.persistentStorage.applicationUser';
+function querySqliteValue(dbPath, key) {
+    const bin = resolveSqlite3Binary();
+    if (!bin)
+        return '';
+    const safe = key.replace(/'/g, "''");
+    const script = `.timeout 60000\nSELECT value FROM ItemTable WHERE key='${safe}';\n`;
+    return execFileSync(bin, ['-noheader', dbPath], {
+        input: script,
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+}
+/** When the cached contract is empty/stale, discover the live reactive blob row in state.vscdb. */
+export function discoverReactiveStorageItemKeyInVscdb(dbPath) {
+    if (!existsSync(dbPath) || !resolveSqlite3Binary())
+        return undefined;
+    try {
+        const suffix = REACTIVE_STORAGE_ITEM_KEY_SUFFIX.replace(/'/g, "''");
+        const key = execFileSync(resolveSqlite3Binary(), [
+            dbPath,
+            `SELECT key FROM ItemTable WHERE key LIKE '%${suffix}%' LIMIT 1;`,
+        ], { encoding: 'utf8' }).trim();
+        if (!key || /['"\\]/.test(key))
+            return undefined;
+        const raw = querySqliteValue(dbPath, key);
+        if (!raw || raw === '{}')
+            return undefined;
+        return key;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function reactiveStorageItemKeyFromContract() {
+    const k = readFileCollectionVscdbContract()?.reactive_storage_item_key;
+    return typeof k === 'string' && k.trim() !== '' ? k.trim() : undefined;
+}
+export function reactiveStorageItemKeyForVscdb(dbPath) {
+    const fromContract = reactiveStorageItemKeyFromContract();
+    if (fromContract)
+        return fromContract;
+    if (dbPath)
+        return discoverReactiveStorageItemKeyInVscdb(dbPath);
+    return undefined;
+}
+export function composerShadowKeysFromContract() {
+    const fromContract = readFileCollectionVscdbContract()?.composer_shadow_keys ?? [];
+    if (fromContract.length > 0)
+        return [...fromContract];
+    return [...CURSOR_COMPOSER_SHADOW_KEYS];
+}
+export function reactiveBlobHasUsableContent(dbPath, reactiveKey) {
+    const raw = querySqliteValue(dbPath, reactiveKey).trim();
+    return raw !== '' && raw !== '{}';
+}

package/dist/log_config_files/readers/vscdb_reader.js

@@ -1,7 +1,9 @@
 import { existsSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { resolveSqlite3Binary } from '../runtime/sqlite_binary.js';
-import { readFileCollectionVscdbContract, sanitizeFileCollectionVscdbContract, sanitizeReactiveStorageItemKey, writeFileCollectionVscdbContract, } from '../runtime/management_storage.js';
+import { mergeCursorShadowKeyValue, mergeShadowKeysIntoComposerState, shadowKeysFromReadQueries, } from './composer_shadow_merge.js';
+import { composerShadowKeysFromContract, reactiveStorageItemKeyForVscdb, } from './vscdb_reactive_storage.js';
+import { readFileCollectionVscdbContract, sanitizeFileCollectionVscdbContract, writeFileCollectionVscdbContract, } from '../runtime/management_storage.js';
 /**
  * ItemTable keys that store a bare JSON boolean; compliance paths use `${key}.${field}`.
  * Kept in sync with `coerceItemTableValueToObjectRoot` / `serializeItemTableValueForWrite` in remediation_sync.
@@ -63,8 +65,16 @@ export function normalizeVscdbComposerContractFromPatternsResponse(resp) {
 /** Persist backend-derived contract next to remediation_instructions.json. */
 export function persistVscdbComposerContractFromPatternsResponse(resp) {
     const norm = normalizeVscdbComposerContractFromPatternsResponse(resp);
-    if (norm.reactive_storage_item_key || norm.composer_shadow_keys.length > 0) {
-        writeFileCollectionVscdbContract(norm);
+    const existing = readFileCollectionVscdbContract();
+    const merged = {
+        version: 1,
+        reactive_storage_item_key: norm.reactive_storage_item_key ?? existing?.reactive_storage_item_key ?? undefined,
+        composer_shadow_keys: norm.composer_shadow_keys.length > 0
+            ? norm.composer_shadow_keys
+            : [...(existing?.composer_shadow_keys ?? [])],
+    };
+    if (merged.reactive_storage_item_key || merged.composer_shadow_keys.length > 0) {
+        writeFileCollectionVscdbContract(merged);
     }
 }
 /**
@@ -87,8 +97,7 @@ export function readVscdbItemTableJson(dbPath, itemKey) {
     }
     try {
         const raw = querySqlite(dbPath, itemKey);
-        const contract = readFileCollectionVscdbContract();
-        const reactiveKey = sanitizeReactiveStorageItemKey(contract?.reactive_storage_item_key) ?? '';
+        const reactiveKey = reactiveStorageItemKeyForVscdb(dbPath) ?? '';
         if (itemKey === 'composerState' && (!raw || raw === '{}') && reactiveKey) {
             const reactive = querySqlite(dbPath, reactiveKey);
             if (reactive) {
@@ -137,6 +146,62 @@ export function readVscdbItemTableJson(dbPath, itemKey) {
         return null;
     }
 }
+/**
+ * Cursor stores web-tool toggles on the reactive blob root and nested `composerState`.
+ * Merge root shadow keys into nested composerState (matches policy_engine.scan_targets).
+ */
+export function mergeComposerShadowKeysFromReactiveBlob(dbPath, merged) {
+    const reactiveKey = reactiveStorageItemKeyForVscdb(dbPath)?.trim();
+    const shadowKeys = composerShadowKeysFromContract();
+    if (!reactiveKey || shadowKeys.length === 0)
+        return;
+    const reactiveWrapped = readVscdbItemTableJson(dbPath, reactiveKey);
+    if (reactiveWrapped === null)
+        return;
+    const blob = reactiveWrapped[reactiveKey];
+    if (!blob || typeof blob !== 'object' || Array.isArray(blob))
+        return;
+    const root = blob;
+    let cs = merged.composerState;
+    if (!cs || typeof cs !== 'object' || Array.isArray(cs)) {
+        const nested = root.composerState;
+        if (nested && typeof nested === 'object' && !Array.isArray(nested)) {
+            cs = { ...nested };
+        }
+        else {
+            cs = {};
+        }
+        merged.composerState = cs;
+    }
+    const composerState = cs;
+    const nestedRoot = root.composerState && typeof root.composerState === 'object' && !Array.isArray(root.composerState)
+        ? root.composerState
+        : undefined;
+    for (const key of shadowKeys) {
+        const value = mergeCursorShadowKeyValue(key, root, nestedRoot ?? composerState);
+        if (value !== undefined) {
+            composerState[key] = value;
+        }
+    }
+}
+/**
+ * After a deferred state.vscdb write, upload the live reactive blob (not stale legacy composerState row).
+ * Return the full blob so the server can apply per-key shadow merge (same as log-config ingest).
+ */
+export function buildVscdbPostApplyRawContent(dbPath, itemKeyFromPath) {
+    if (itemKeyFromPath === 'composerState') {
+        const reactiveKey = reactiveStorageItemKeyForVscdb(dbPath);
+        if (reactiveKey) {
+            const reactiveWrapped = readVscdbItemTableJson(dbPath, reactiveKey);
+            const blob = reactiveWrapped?.[reactiveKey];
+            if (blob && typeof blob === 'object' && !Array.isArray(blob)) {
+                return { ...blob };
+            }
+        }
+        return readVscdbItemTableJson(dbPath, itemKeyFromPath);
+    }
+    return readVscdbItemTableJson(dbPath, itemKeyFromPath);
+}
 function setNested(obj, dotPath, value) {
     const parts = dotPath.split('.');
     const safe = (k) => k !== '__proto__' && k !== 'constructor' && k !== 'prototype';
@@ -172,16 +237,15 @@ function runOneStep(dbPath, stateData, step) {
                     stateData.composerState = composerState;
                 }
                 if (step.include_keys?.length) {
-                    const nested = composerState && typeof composerState === 'object'
+                    const nested = composerState && typeof composerState === 'object' && !Array.isArray(composerState)
                         ? composerState
                         : undefined;
+                    if (!nested)
+                        return;
                     for (const k of step.include_keys) {
-                        // Reactive blob root wins over nested composerState (matches policy_engine.scan_targets merge).
-                        if (k in obj && obj[k] !== undefined) {
-                            stateData[k] = obj[k];
-                        }
-                        else if (nested && k in nested && nested[k] !== undefined) {
-                            stateData[k] = nested[k];
+                        const merged = mergeCursorShadowKeyValue(k, obj, nested);
+                        if (merged !== undefined) {
+                            nested[k] = merged;
                         }
                     }
                 }
@@ -243,6 +307,7 @@ export function readVSCDBState(dbPath, readQueries, mergeFromComposerStateKeys)
         if (mergeFromComposerStateKeys?.length) {
             mergeFromComposerState(stateData, mergeFromComposerStateKeys);
         }
+        mergeShadowKeysIntoComposerState(stateData, shadowKeysFromReadQueries(readQueries));
         return Object.keys(stateData).length > 0 ? stateData : null;
     }
     catch (error) {

package/dist/log_config_files/runtime/compliance_check.js

@@ -13,14 +13,15 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { readVscdbItemTableJson } from '../readers/vscdb_reader.js';
-import { readFileCollectionVscdbContract, readRemediationInstructionsFile, writeRemediationInstructionsFile, } from './management_storage.js';
+import { mergeComposerShadowKeysFromReactiveBlob, readVscdbItemTableJson, } from '../readers/vscdb_reader.js';
+import { readRemediationInstructionsFile, writeRemediationInstructionsFile, } from './management_storage.js';
 import { resolveRemediationConfigPath } from './remediation_config_path.js';
+import { isRemediationQuarantined, markRemediationApplyPendingVerification, processPendingPostRestartVerifications, } from './remediation_apply_tracking.js';
 import { complianceRunnerDiag, hookRunLog, logRemediationApplyFailure } from './hook_logger.js';
 import { loadEndpointBase } from '../sender/endpoint_config.js';
 import { resolveHardwareUuid, tryResolveHardwareUuid } from './hardware_uuid.js';
 import { buildDeferredCursorRestartCommand, discoverAllWorkspaceVscdbs, enforceRemediation, fetchSync, isTrustedRestartCommandForAutofix, remediationFixSpec, reportAutofixApplied, syncRemediations, } from './remediation_sync.js';
-import { sendConfigFile, resolveRepoFromPath } from '../sender/batch_sender.js';
+import { sendConfigFile } from '../sender/batch_sender.js';
 import { ensureAuthentication } from '../auth/auth_flow.js';
 /** Normalize manifest/env/CLI agent tokens to a known Agent, or '' if unrecognized. */
 export function normalizeAgentToken(raw) {
@@ -84,6 +85,28 @@ export function itemTableKeyFromSettingPath(settingPath) {
     const i = settingPath.indexOf('.');
     return i === -1 ? settingPath : settingPath.slice(0, i);
 }
+/**
+ * Compliance reads the live config at `config_file_path` (#itemKey), but sqlite apply may target
+ * a different ItemTable row. Verify against the manifest path's item key, not the apply target.
+ */
+export function canonicalComplianceSettingPath(configFilePath, check) {
+    const settingPath = check.setting_path;
+    const applyKey = check.sqlite_op?.target_key?.trim();
+    if (!applyKey || applyKey === settingPath)
+        return settingPath;
+    const hashIdx = configFilePath.indexOf('#');
+    if (hashIdx < 0)
+        return settingPath;
+    const verifyKey = configFilePath.slice(hashIdx + 1).trim();
+    if (!verifyKey || applyKey === verifyKey)
+        return settingPath;
+    const prefix = `${applyKey}.`;
+    if (settingPath === applyKey)
+        return verifyKey;
+    if (settingPath.startsWith(prefix))
+        return `${verifyKey}${settingPath.slice(applyKey.length)}`;
+    return settingPath;
+}
 /** Traverse a JSON object using dot-notation path. Returns undefined if any segment is missing. */
 export function getByPath(obj, path) {
     const parts = path.split('.');
@@ -179,42 +202,8 @@ function shouldMergeComposerShadowKeys(itemKeyFromPath, checkSettingPaths) {
         return true;
     return checkSettingPaths.some((p) => p === 'composerState' || p.startsWith('composerState.'));
 }
-/**
- * Cursor stores web-tool toggles on the reactive blob root and nested `composerState`.
- * Policy scan merges root shadow keys into composerState; compliance must match or autofix
- * never runs when nested values are stale (e.g. lastBrowserConnectionMode none vs root editor).
- */
-export function mergeComposerShadowKeysFromReactiveBlob(dbPath, merged) {
-    const contract = readFileCollectionVscdbContract();
-    const reactiveKey = contract?.reactive_storage_item_key?.trim();
-    const shadowKeys = contract?.composer_shadow_keys ?? [];
-    if (!reactiveKey || shadowKeys.length === 0)
-        return;
-    const reactiveWrapped = readVscdbItemTableJson(dbPath, reactiveKey);
-    if (reactiveWrapped === null)
-        return;
-    const blob = reactiveWrapped[reactiveKey];
-    if (!blob || typeof blob !== 'object' || Array.isArray(blob))
-        return;
-    const root = blob;
-    let cs = merged.composerState;
-    if (!cs || typeof cs !== 'object' || Array.isArray(cs)) {
-        const nested = root.composerState;
-        if (nested && typeof nested === 'object' && !Array.isArray(nested)) {
-            cs = { ...nested };
-        }
-        else {
-            cs = {};
-        }
-        merged.composerState = cs;
-    }
-    const composerState = cs;
-    for (const key of shadowKeys) {
-        if (Object.prototype.hasOwnProperty.call(root, key) && root[key] !== undefined) {
-            composerState[key] = root[key];
-        }
-    }
-}
+/** @deprecated Import from vscdb_reader — re-export for existing tests. */
+export { mergeComposerShadowKeysFromReactiveBlob } from '../readers/vscdb_reader.js';
 /** Plain JSON file or virtual `…/state.vscdb#itemKey` path for ItemTable-backed settings. */
 function loadRemediationConfigJson(configFilePath, checkSettingPaths = []) {
     const resolvedPath = resolveRemediationConfigPath(configFilePath);
@@ -270,6 +259,101 @@ function evaluateSecondaryGroup(group) {
 // ---------------------------------------------------------------------------
 // Check runner — Section 6: real per-check evaluation
 // ---------------------------------------------------------------------------
+function violationFromCheck(entry, compliance, check, expected) {
+    return {
+        uuid: entry.uuid,
+        finding_formatted_id: compliance.finding_formatted_id,
+        setting_path: check.setting_path,
+        description: check.description,
+        finding_title: entry.finding_title,
+        finding_description: entry.finding_description,
+        policy_name: entry.policy_name,
+        severity: compliance.severity,
+        autofix_allowed: compliance.autofix_allowed,
+        config_file_path: entry.config_file_path,
+        expected_value: expected,
+        message: `[${compliance.finding_formatted_id}] ${entry.finding_title ?? compliance.description}\nDescription: ${entry.finding_description ?? compliance.description}\nHow to fix: Apply remediation ops for ${check.setting_path} in ${entry.config_file_path}`,
+    };
+}
+/** Evaluate one manifest row against on-disk config (used by gate + post-restart verify). */
+export function evaluateManifestEntryCompliance(entry) {
+    const compliance = entry.fix ?? entry.compliance;
+    if (!compliance || compliance.file_format !== 'json')
+        return { violations: [] };
+    const checks = compliance.checks ?? [];
+    if (checks.length === 0)
+        return { violations: [] };
+    const loaded = loadRemediationConfigJson(entry.config_file_path, checks.map((c) => c.setting_path));
+    if (!loaded.ok)
+        return { violations: [] };
+    const configJson = loaded.json;
+    const entryViolations = [];
+    for (const check of checks) {
+        const effectivePath = canonicalComplianceSettingPath(entry.config_file_path, check);
+        if (check.sqlite_op?.apply_to_all_workspaces && check.ops) {
+            const segments = check.sqlite_op.workspace_storage_path_segments ?? [
+                'Library', 'Application Support', 'Cursor', 'User', 'workspaceStorage',
+            ];
+            const wsPath = join(homedir(), ...segments);
+            const vscdbPaths = discoverAllWorkspaceVscdbs(wsPath);
+            if (vscdbPaths.length === 0)
+                continue;
+            let violated = false;
+            let expectedForViolation = null;
+            for (const dbPath of vscdbPaths) {
+                const wrapped = readVscdbItemTableJson(dbPath, check.sqlite_op.target_key ?? '');
+                if (wrapped === null) {
+                    violated = true;
+                    expectedForViolation = { op: 'read_failed', db: dbPath };
+                    break;
+                }
+                const { ok, expected } = verifyOpsApplied(wrapped, check.setting_path, check.ops);
+                if (!ok) {
+                    violated = true;
+                    expectedForViolation = expected;
+                    break;
+                }
+            }
+            if (violated) {
+                entryViolations.push(violationFromCheck(entry, compliance, check, expectedForViolation));
+            }
+            continue;
+        }
+        if (check.ops) {
+            const { ok, expected } = verifyOpsApplied(configJson, effectivePath, check.ops);
+            if (!ok) {
+                entryViolations.push(violationFromCheck(entry, compliance, { ...check, setting_path: effectivePath }, expected));
+            }
+            continue;
+        }
+        const currentValue = getByPath(configJson, effectivePath);
+        const leafKey = effectivePath.split('.').pop();
+        const expectedValue = check.after?.[leafKey];
+        if (expectedValue === undefined)
+            continue;
+        if (!deepEqual(currentValue, expectedValue)) {
+            entryViolations.push(violationFromCheck(entry, compliance, { ...check, setting_path: effectivePath }, expectedValue));
+        }
+    }
+    if (entryViolations.length === 0)
+        return { violations: [] };
+    const secondaryGroups = compliance.secondary_checks ?? [];
+    const passingGroup = secondaryGroups.length > 0 ? secondaryGroups.find((g) => evaluateSecondaryGroup(g)) : undefined;
+    if (passingGroup) {
+        return {
+            violations: [],
+            secondarySatisfied: {
+                uuid: entry.uuid,
+                config_file_path: passingGroup.config_file_path,
+                file_type: passingGroup.file_type,
+            },
+        };
+    }
+    return { violations: entryViolations };
+}
+export function collectManifestEntryViolations(entry) {
+    return evaluateManifestEntryCompliance(entry).violations;
+}
 /**
  * Evaluate current on-disk configs against remediation_instructions.json only (no server).
  * Returns status for prompt gating / callers; does not persist compliance.json.
@@ -300,12 +384,11 @@ export function runLocalRemediationComplianceCheck(agent = 'cursor') {
                 hookRunLog(`compliance_check: skipping non-json entry uuid=${entry.uuid}`);
                 continue;
             }
-            const checks = compliance.checks ?? [];
-            if (checks.length === 0) {
+            if ((compliance.checks ?? []).length === 0) {
                 skippedNoChecks++;
                 continue;
             }
-            const loaded = loadRemediationConfigJson(entry.config_file_path, checks.map((c) => c.setting_path));
+            const loaded = loadRemediationConfigJson(entry.config_file_path, (compliance.checks ?? []).map((c) => c.setting_path));
             if (!loaded.ok) {
                 skippedUnreadable++;
                 const msg = loaded.reason === 'file_not_found'
@@ -327,121 +410,16 @@ export function runLocalRemediationComplianceCheck(agent = 'cursor') {
                 });
                 continue;
             }
-            const configJson = loaded.json;
-            const entryViolations = [];
-            for (const check of checks) {
-                // When the check carries a sqlite_op with apply_to_all_workspaces, the authoritative data
-                // lives in workspace state.vscdb files — not in config_file_path (which may be mcp.json in
-                // the fallback case where no workspace vscdb has been collected yet). Verify directly against
-                // every discovered workspace vscdb; fail as a violation if any is missing the required entry.
-                if (check.sqlite_op?.apply_to_all_workspaces && check.ops) {
-                    const segments = check.sqlite_op.workspace_storage_path_segments ?? [
-                        'Library', 'Application Support', 'Cursor', 'User', 'workspaceStorage',
-                    ];
-                    const wsPath = join(homedir(), ...segments);
-                    const vscdbPaths = discoverAllWorkspaceVscdbs(wsPath);
-                    if (vscdbPaths.length === 0) {
-                        hookRunLog(`compliance_check: apply_to_all_workspaces — no workspace vscdbs found at ${wsPath}, skipping uuid=${entry.uuid}`);
-                    }
-                    else {
-                        let violated = false;
-                        let expectedForViolation = null;
-                        for (const dbPath of vscdbPaths) {
-                            const wrapped = readVscdbItemTableJson(dbPath, check.sqlite_op.target_key ?? '');
-                            if (wrapped === null) {
-                                violated = true;
-                                expectedForViolation = { op: 'read_failed', db: dbPath };
-                                break;
-                            }
-                            const { ok, expected } = verifyOpsApplied(wrapped, check.setting_path, check.ops);
-                            if (!ok) {
-                                violated = true;
-                                expectedForViolation = expected;
-                                break;
-                            }
-                        }
-                        if (violated) {
-                            hookRunLog(`compliance_check: VIOLATION (vscdb) uuid=${entry.uuid} path=${check.setting_path} expected=${JSON.stringify(expectedForViolation)}`);
-                            entryViolations.push({
-                                uuid: entry.uuid,
-                                finding_formatted_id: compliance.finding_formatted_id,
-                                setting_path: check.setting_path,
-                                description: check.description,
-                                finding_title: entry.finding_title,
-                                finding_description: entry.finding_description,
-                                policy_name: entry.policy_name,
-                                severity: compliance.severity,
-                                autofix_allowed: compliance.autofix_allowed,
-                                config_file_path: entry.config_file_path,
-                                expected_value: expectedForViolation,
-                                message: `[${compliance.finding_formatted_id}] ${entry.finding_title ?? compliance.description}\nDescription: ${entry.finding_description ?? compliance.description}\nHow to fix: Apply remediation ops for ${check.setting_path} in workspace state.vscdb files`,
-                            });
-                        }
-                    }
-                    continue;
-                }
-                // Prefer ops-based verification (matches delta apply semantics; doesn't require full after snapshot).
-                if (check.ops) {
-                    const { ok, expected } = verifyOpsApplied(configJson, check.setting_path, check.ops);
-                    if (!ok) {
-                        hookRunLog(`compliance_check: VIOLATION uuid=${entry.uuid} path=${check.setting_path} expected=${JSON.stringify(expected)}`);
-                        entryViolations.push({
-                            uuid: entry.uuid,
-                            finding_formatted_id: compliance.finding_formatted_id,
-                            setting_path: check.setting_path,
-                            description: check.description,
-                            finding_title: entry.finding_title,
-                            finding_description: entry.finding_description,
-                            policy_name: entry.policy_name,
-                            severity: compliance.severity,
-                            autofix_allowed: compliance.autofix_allowed,
-                            config_file_path: entry.config_file_path,
-                            expected_value: expected,
-                            message: `[${compliance.finding_formatted_id}] ${entry.finding_title ?? compliance.description}\nDescription: ${entry.finding_description ?? compliance.description}\nHow to fix: Apply remediation ops for ${check.setting_path} in ${entry.config_file_path}`,
-                        });
-                    }
-                    continue;
-                }
-                // Backwards compat: old local files may still carry after snapshots.
-                const currentValue = getByPath(configJson, check.setting_path);
-                const leafKey = check.setting_path.split('.').pop();
-                const expectedValue = check.after?.[leafKey];
-                if (expectedValue === undefined)
-                    continue;
-                if (!deepEqual(currentValue, expectedValue)) {
-                    hookRunLog(`compliance_check: VIOLATION uuid=${entry.uuid} path=${check.setting_path} current=${JSON.stringify(currentValue)} expected=${JSON.stringify(expectedValue)}`);
-                    entryViolations.push({
-                        uuid: entry.uuid,
-                        finding_formatted_id: compliance.finding_formatted_id,
-                        setting_path: check.setting_path,
-                        description: check.description,
-                        finding_title: entry.finding_title,
-                        finding_description: entry.finding_description,
-                        policy_name: entry.policy_name,
-                        severity: compliance.severity,
-                        autofix_allowed: compliance.autofix_allowed,
-                        config_file_path: entry.config_file_path,
-                        expected_value: expectedValue,
-                        message: `[${compliance.finding_formatted_id}] ${entry.finding_title ?? compliance.description}\nDescription: ${entry.finding_description ?? compliance.description}\nHow to fix: Set ${check.setting_path} to ${JSON.stringify(expectedValue)} in ${entry.config_file_path}`,
-                    });
-                }
+            const { violations: entryViolations, secondarySatisfied: entrySecondary } = evaluateManifestEntryCompliance(entry);
+            for (const v of entryViolations) {
+                hookRunLog(`compliance_check: VIOLATION uuid=${entry.uuid} path=${v.setting_path} expected=${JSON.stringify(v.expected_value)}`);
             }
-            if (entryViolations.length > 0) {
-                const secondaryGroups = compliance.secondary_checks ?? [];
-                const passingGroup = secondaryGroups.length > 0
-                    ? secondaryGroups.find((g) => evaluateSecondaryGroup(g))
-                    : undefined;
-                if (passingGroup) {
-                    hookRunLog(`compliance_check: secondary check satisfied uuid=${entry.uuid} — skipping ${entryViolations.length} primary violation(s)`);
-                    secondarySatisfied.push({
-                        uuid: entry.uuid,
-                        config_file_path: passingGroup.config_file_path,
-                        file_type: passingGroup.file_type,
-                    });
-                }
-                else {
-                    violations.push(...entryViolations);
-                }
+            if (entrySecondary) {
+                hookRunLog(`compliance_check: secondary check satisfied uuid=${entry.uuid} — skipping primary violation(s)`);
+                secondarySatisfied.push(entrySecondary);
+            }
+            else if (entryViolations.length > 0) {
+                violations.push(...entryViolations);
             }
         }
         const status = {
@@ -485,6 +463,34 @@ export function runLocalRemediationComplianceCheck(agent = 'cursor') {
         return fallback;
     }
 }
+/**
+ * After restart, verify pending remediations and report outcomes to the server.
+ */
+export function reportPostRestartVerificationOutcomes(violations) {
+    const { remediations } = readRemediationInstructionsFile();
+    const entriesByUuid = new Map(remediations.map((entry) => [entry.uuid, entry]));
+    const outcomes = processPendingPostRestartVerifications((uuid) => {
+        const entry = entriesByUuid.get(uuid);
+        if (entry && collectManifestEntryViolations(entry).length > 0)
+            return true;
+        return violations.some((v) => v.uuid === uuid);
+    });
+    const reportPromises = outcomes.map((o) => {
+        if (o.status === 'quarantined' || o.status === 'verification_failed') {
+            logRemediationApplyFailure('post_restart_verification_failed', {
+                uuid: o.uuid,
+                reason: o.reason ?? 'Setting unchanged after apply',
+                status: o.status,
+                consecutive_failures: o.consecutive_failures,
+            });
+        }
+        return reportAutofixApplied(o.uuid, o.status, {
+            failure_reason: o.reason,
+            consecutive_failures: o.consecutive_failures,
+        });
+    });
+    return { outcomes, reportPromises };
+}
 export function applyAutofixViolations(violations, agent = 'cursor') {
     for (const v of violations) {
         if (!v.autofix_allowed) {
@@ -520,6 +526,18 @@ export function applyAutofixViolations(violations, agent = 'cursor') {
     for (const violation of autofixable) {
         if (seen.has(violation.uuid))
             continue;
+        if (isRemediationQuarantined(violation.uuid)) {
+            hookRunLog(`autofix: skipped quarantined uuid=${violation.uuid}`);
+            logRemediationApplyFailure('autofix_skipped_quarantined', {
+                uuid: violation.uuid,
+                finding_formatted_id: violation.finding_formatted_id,
+                config_file_path: violation.config_file_path,
+                setting_path: violation.setting_path,
+                reason: 'Auto-fix paused after repeated post-restart verification failures — agent config may have changed',
+            });
+            failedViolations.push(violation);
+            continue;
+        }
         const instruction = byUuid.get(violation.uuid);
         if (!instruction) {
             hookRunLog(`autofix: no instruction found for uuid=${violation.uuid}, skipping`);
@@ -548,6 +566,10 @@ export function applyAutofixViolations(violations, agent = 'cursor') {
         appliedViolations.push(violation);
         hookRunLog(`autofix: applied uuid=${inst.uuid} path=${configPathForDisk}`);
         reportPromises.push(reportAutofixApplied(inst.uuid, 'success'));
+        // Every successful autofix (Cursor + Claude, restart or immediate JSON) awaits verification on
+        // the next compliance check so we can quarantine stuck applies and stop restart/retry loops.
+        markRemediationApplyPendingVerification(inst.uuid);
+        const spec = remediationFixSpec(inst);
         if (er.deferredSqlite && configPathForDisk.includes('#')) {
             hookRunLog(`autofix: skip immediate vscdb upload (deferred until after restart) uuid=${inst.uuid}`);
         }
@@ -572,11 +594,10 @@ export function applyAutofixViolations(violations, agent = 'cursor') {
                 if (fileType) {
                     const hw = tryResolveHardwareUuid();
                     if (hw) {
-                        const repoIdentifier = resolveRepoFromPath(configPathForDisk);
                         // Do not rely on the bulk uploader (start-every-prompt throttles at 1800s).
                         // Always attempt to upload the single remediated file immediately.
                         reportPromises.push(ensureAuthentication(hw)
-                            .then((authKey) => sendConfigFile({ file_type: fileType, file_path: configPathForDisk, raw_content: updatedContent }, hw, authKey, repoIdentifier))
+                            .then((authKey) => sendConfigFile({ file_type: fileType, file_path: configPathForDisk, raw_content: updatedContent }, hw, authKey))
                             .then((sentOk) => {
                             hookRunLog(`autofix: uploaded remediated file uuid=${inst.uuid} path=${configPathForDisk} ok=${sentOk}`);
                         })
@@ -598,7 +619,6 @@ export function applyAutofixViolations(violations, agent = 'cursor') {
                 }
             }
         }
-        const spec = remediationFixSpec(inst);
         if (spec?.restart_required && spec.restart_command) {
             if (!er.deferredSqlite) {
                 if (isTrustedRestartCommandForAutofix(spec.restart_command)) {

package/dist/log_config_files/runtime/remediation_apply_tracking.js

@@ -0,0 +1,138 @@
+/**
+ * Tracks remediation apply attempts and post-apply verification (next compliance check)
+ * so we do not restart-loop or retry forever when an agent config format changed and
+ * autofix can never stick. Applies to every remediation on Cursor and Claude.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { atomicWriteJson, getManagementDir } from './management_storage.js';
+import { hookRunLog } from './hook_logger.js';
+export const REMEDIATION_APPLY_TRACKING_BASENAME = 'remediation_apply_tracking.json';
+/** Consecutive post-restart verification failures before we stop autofix for a UUID. */
+export const MAX_CONSECUTIVE_VERIFY_FAILURES = 1;
+export function getRemediationApplyTrackingPath() {
+    return join(getManagementDir(), REMEDIATION_APPLY_TRACKING_BASENAME);
+}
+function emptyTrackingFile() {
+    return { entries: {} };
+}
+export function readRemediationApplyTrackingFile() {
+    const path = getRemediationApplyTrackingPath();
+    if (!existsSync(path))
+        return emptyTrackingFile();
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || !parsed.entries || typeof parsed.entries !== 'object') {
+            return emptyTrackingFile();
+        }
+        return parsed;
+    }
+    catch {
+        return emptyTrackingFile();
+    }
+}
+export function writeRemediationApplyTrackingFile(file) {
+    atomicWriteJson(getRemediationApplyTrackingPath(), file);
+}
+function defaultEntry() {
+    return { consecutive_verify_failures: 0, quarantined: false };
+}
+export function getRemediationApplyTrackingEntry(uuid) {
+    const file = readRemediationApplyTrackingFile();
+    return file.entries[uuid] ?? defaultEntry();
+}
+export function isRemediationQuarantined(uuid) {
+    return getRemediationApplyTrackingEntry(uuid).quarantined === true;
+}
+/** Admin retry: reset quarantine counters so autofix can run again on next prompt. */
+export function clearRemediationApplyQuarantine(uuid) {
+    const file = readRemediationApplyTrackingFile();
+    const prev = file.entries[uuid];
+    if (!prev)
+        return;
+    file.entries[uuid] = {
+        consecutive_verify_failures: 0,
+        quarantined: false,
+        pending_post_restart_verify: false,
+    };
+    writeRemediationApplyTrackingFile(file);
+    hookRunLog(`remediation_tracking: quarantine_cleared uuid=${uuid}`);
+}
+export function markRemediationApplyPendingVerification(uuid) {
+    const file = readRemediationApplyTrackingFile();
+    const prev = file.entries[uuid] ?? defaultEntry();
+    file.entries[uuid] = {
+        ...prev,
+        pending_post_restart_verify: true,
+        last_apply_at: new Date().toISOString(),
+    };
+    writeRemediationApplyTrackingFile(file);
+    hookRunLog(`remediation_tracking: pending_post_restart_verify uuid=${uuid}`);
+}
+export function markRemediationApplyVerified(uuid) {
+    const file = readRemediationApplyTrackingFile();
+    const prev = file.entries[uuid] ?? defaultEntry();
+    const next = {
+        ...prev,
+        pending_post_restart_verify: false,
+        consecutive_verify_failures: 0,
+        quarantined: false,
+        last_failure_reason: undefined,
+        quarantined_at: undefined,
+    };
+    file.entries[uuid] = next;
+    writeRemediationApplyTrackingFile(file);
+    hookRunLog(`remediation_tracking: verified uuid=${uuid}`);
+    return next;
+}
+export function recordRemediationVerificationFailure(uuid, reason) {
+    const file = readRemediationApplyTrackingFile();
+    const prev = file.entries[uuid] ?? defaultEntry();
+    const failures = (prev.consecutive_verify_failures ?? 0) + 1;
+    const quarantined = failures >= MAX_CONSECUTIVE_VERIFY_FAILURES;
+    const next = {
+        ...prev,
+        pending_post_restart_verify: false,
+        consecutive_verify_failures: failures,
+        quarantined,
+        last_failure_reason: reason,
+        ...(quarantined ? { quarantined_at: new Date().toISOString() } : {}),
+    };
+    file.entries[uuid] = next;
+    writeRemediationApplyTrackingFile(file);
+    hookRunLog(`remediation_tracking: verification_failed uuid=${uuid} failures=${failures} quarantined=${quarantined}`);
+    return { entry: next, newlyQuarantined: quarantined && !prev.quarantined };
+}
+/**
+ * For each UUID awaiting post-restart verification, decide pass/fail.
+ *
+ * Prefer a per-UUID probe (re-runs that remediation's checks on disk). A Set of UUIDs is
+ * supported for unit tests only — do not use a global violation list from compliance_check
+ * in production: shadow-key merge bugs once made that list empty while the setting was still
+ * wrong, which incorrectly marked remediations verified.
+ */
+export function processPendingPostRestartVerifications(violationProbe) {
+    const isStillViolating = typeof violationProbe === 'function'
+        ? violationProbe
+        : (uuid) => violationProbe.has(uuid);
+    const file = readRemediationApplyTrackingFile();
+    const outcomes = [];
+    for (const [uuid, entry] of Object.entries(file.entries)) {
+        if (!entry.pending_post_restart_verify)
+            continue;
+        if (!isStillViolating(uuid)) {
+            markRemediationApplyVerified(uuid);
+            outcomes.push({ uuid, status: 'verified', consecutive_failures: 0 });
+            continue;
+        }
+        const reason = 'Setting unchanged after apply — the agent may have changed its config format and auto-fix cannot apply this policy.';
+        const { entry: updated, newlyQuarantined } = recordRemediationVerificationFailure(uuid, reason);
+        outcomes.push({
+            uuid,
+            status: newlyQuarantined || updated.quarantined ? 'quarantined' : 'verification_failed',
+            reason,
+            consecutive_failures: updated.consecutive_verify_failures,
+        });
+    }
+    return outcomes;
+}

package/dist/log_config_files/runtime/remediation_sync.js

@@ -4,18 +4,21 @@ import { homedir } from 'node:os';
 import { execFileSync } from 'node:child_process';
 import { executeGet, executeBody } from '../../endpoint_client/http_transport.js';
 import { complianceRunnerDiag, hookRunLog, logRemediationApplyFailure } from './hook_logger.js';
-import { atomicWriteJson, getDeferredVscdbApplyPath, getFileCollectionVscdbContractPath, getRemediationInstructionsPath, readFileCollectionVscdbContract, readRemediationInstructionsFile, writeRemediationInstructionsFile, } from './management_storage.js';
+import { atomicWriteJson, getDeferredVscdbApplyPath, getFileCollectionVscdbContractPath, getRemediationInstructionsPath, readRemediationInstructionsFile, writeRemediationInstructionsFile, } from './management_storage.js';
 import { readStoredAuthKey } from '../auth/auth_key_store.js';
 import { createSignature } from '../sender/signing.js';
 import { loadEndpointBase } from '../sender/endpoint_config.js';
 import { tryResolveHardwareUuid } from './hardware_uuid.js';
-import { CURSOR_SCALAR_ITEMTABLE_FIELDS, persistVscdbComposerContractFromPatternsResponse, readVscdbItemTableJson, } from '../readers/vscdb_reader.js';
+import { clearRemediationApplyQuarantine, readRemediationApplyTrackingFile, writeRemediationApplyTrackingFile, } from './remediation_apply_tracking.js';
+import { CURSOR_SCALAR_ITEMTABLE_FIELDS, buildVscdbPostApplyRawContent, persistVscdbComposerContractFromPatternsResponse, } from '../readers/vscdb_reader.js';
 import { sendConfigFile } from '../sender/batch_sender.js';
 import { parseWorktreeRootFromPath } from './worktree_scanner.js';
 import { reportAbsentWorktrees } from './worktree_absent.js';
 import { buildApiUrl, getFileCollectionPatterns } from '../../endpoint_client/registry_api.js';
 import { resolveRemediationConfigPath } from './remediation_config_path.js';
 import { resolveSqlite3Binary } from './sqlite_binary.js';
+import { CURSOR_COMPOSER_SHADOW_KEYS } from '../readers/cursor_shadow_merge_policy.js';
+import { REACTIVE_STORAGE_ITEM_KEY_SUFFIX, composerShadowKeysFromContract, reactiveStorageItemKeyForVscdb, } from '../readers/vscdb_reactive_storage.js';
 /** Best-effort detail from execFileSync failures (stderr, exit code, errno). */
 function formatNodeChildException(err) {
     if (!(err instanceof Error)) {
@@ -38,12 +41,8 @@ function formatNodeChildException(err) {
     const long = bits.join(' | ');
     return { short: bits.slice(0, 2).join(' | '), long };
 }
-function reactiveStorageItemKeyFromContract() {
-    const k = readFileCollectionVscdbContract()?.reactive_storage_item_key;
-    return typeof k === 'string' && k.trim() !== '' ? k.trim() : undefined;
-}
 function composerShadowKeySetFromContract() {
-    return new Set(readFileCollectionVscdbContract()?.composer_shadow_keys ?? []);
+    return new Set(composerShadowKeysFromContract());
 }
 /** Resolve fix payload from API or legacy `compliance` key in local JSON. */
 export function remediationFixSpec(inst) {
@@ -119,9 +118,44 @@ async function ensureInstructionsForUuids(endpointBase, machineUuid, want, overl
         writeInstructions(payload);
     }
 }
-// ---------------------------------------------------------------------------
-// API helpers
-// ---------------------------------------------------------------------------
+function applyClearApplyTrackingUuids(uuids) {
+    if (!uuids?.length)
+        return;
+    for (const uuid of uuids) {
+        clearRemediationApplyQuarantine(uuid);
+        hookRunLog(`remediation_sync: cleared apply quarantine uuid=${uuid}`);
+    }
+}
+/** When the server redeploys enforcement under a new UUID, keep local quarantine state. */
+function transferQuarantineForRetiredUuids(removed, added, retiredInstructions, addedInstructions) {
+    if (removed.length === 0 || added.length === 0 || addedInstructions.length === 0)
+        return;
+    const file = readRemediationApplyTrackingFile();
+    let changed = false;
+    for (const removedUuid of removed) {
+        const prev = file.entries[removedUuid];
+        if (!prev?.quarantined)
+            continue;
+        const retired = retiredInstructions.find((r) => r.uuid === removedUuid);
+        const retiredPath = retired?.config_file_path ?? '';
+        for (const inst of addedInstructions) {
+            if (!added.includes(inst.uuid))
+                continue;
+            if (retiredPath && inst.config_file_path !== retiredPath)
+                continue;
+            file.entries[inst.uuid] = {
+                ...prev,
+                pending_post_restart_verify: false,
+            };
+            changed = true;
+            hookRunLog(`remediation_sync: transferred quarantine ${removedUuid} -> ${inst.uuid} path=${inst.config_file_path}`);
+        }
+        delete file.entries[removedUuid];
+        changed = true;
+    }
+    if (changed)
+        writeRemediationApplyTrackingFile(file);
+}
 export async function fetchSync(endpointBase, machineUuid, activeUuids, timeoutMs = 8000) {
     const uuidsParam = activeUuids.join(',');
     const url = `${buildApiUrl(endpointBase, '/api/findings/remediations/sync/')}?machine_uuid=${encodeURIComponent(machineUuid)}&active_uuids=${encodeURIComponent(uuidsParam)}`;
@@ -436,13 +470,13 @@ function cursorVscdbHasUsableComposerStateRow(dbPath, sqliteOp) {
 function resolveCursorComposerSqliteOp(dbPath, sqliteOp) {
     if (sqliteOp.target_key !== 'composerState')
         return sqliteOp;
-    const reactiveKey = reactiveStorageItemKeyFromContract();
+    const reactiveKey = reactiveStorageItemKeyForVscdb(dbPath);
     /** Merge into applicationUser (or equivalent) JSON: inner `composerState` or nested path under it. */
     const resolveToReactive = () => {
         if (!reactiveKey)
             return sqliteOp;
         const jp = (sqliteOp.json_path ?? '').trim();
-        if (!jp) {
+        if (!jp || jp === 'composerState') {
             return {
                 ...sqliteOp,
                 target_key: reactiveKey,
@@ -607,8 +641,18 @@ function mergeSqliteOpIntoJson(currentJson, sqliteOp) {
         arr.push(newItem);
         return;
     }
-    mergeJsonAtSqlitePath(currentJson, sqliteOp.json_path, sqliteOp.updates);
-    mirrorComposerShadowKeysToReactiveRoot(currentJson, sqliteOp);
+    const updates = sqliteOp.updates ?? {};
+    let jsonPath = sqliteOp.json_path ?? '';
+    const shadowKeys = new Set(CURSOR_COMPOSER_SHADOW_KEYS);
+    if (!jsonPath.trim() && Object.keys(updates).some((k) => shadowKeys.has(k))) {
+        const nested = currentJson.composerState;
+        if (nested && typeof nested === 'object' && !Array.isArray(nested)) {
+            jsonPath = 'composerState';
+        }
+    }
+    mergeJsonAtSqlitePath(currentJson, jsonPath, updates);
+    const opForMirror = jsonPath === (sqliteOp.json_path ?? '') ? sqliteOp : { ...sqliteOp, json_path: jsonPath };
+    mirrorComposerShadowKeysToReactiveRoot(currentJson, opForMirror);
 }
 /**
  * Cursor remediations historically used json_path `composerState.` (trailing dot). That yields an empty
@@ -632,8 +676,13 @@ function repairComposerStateEmptySegmentBug(root) {
  * Skips array-target ops (`modes4`, etc.).
  */
 function mirrorComposerShadowKeysToReactiveRoot(root, resolvedOp) {
-    const rk = reactiveStorageItemKeyFromContract();
-    if (!rk || resolvedOp.target_key !== rk)
+    const targetKey = resolvedOp.target_key;
+    const contractKey = reactiveStorageItemKeyForVscdb();
+    const reactiveTarget = (contractKey && targetKey === contractKey) ||
+        (typeof targetKey === 'string' &&
+            targetKey.includes(REACTIVE_STORAGE_ITEM_KEY_SUFFIX) &&
+            !/['"\\]/.test(targetKey));
+    if (!reactiveTarget)
         return;
     const where = resolvedOp.array_item_where;
     if (where && typeof where === 'object' && Object.keys(where).length > 0)
@@ -845,7 +894,7 @@ export async function applyDeferredVscdbFromDisk() {
             const itemKey = u.file_path.slice(hi + 1).trim();
             if (!itemKey)
                 continue;
-            const rawContent = readVscdbItemTableJson(dbPath, itemKey);
+            const rawContent = buildVscdbPostApplyRawContent(dbPath, itemKey);
             if (rawContent === null) {
                 hookRunLog(`deferred_vscdb: post-apply read failed path=${u.file_path}`);
                 continue;
@@ -1245,16 +1294,13 @@ export function enforceRemediation(instruction) {
         return { ok: false, failureReason: `exception: ${msg}` };
     }
 }
-// ---------------------------------------------------------------------------
-// Autofix reporting
-// ---------------------------------------------------------------------------
 /**
  * Fire-and-forget: notify the server that this machine applied an autofix for the given
  * remediation UUID. Creates one EnforcementLog row on the server for the audit trail.
  * Never throws — any failure is logged and silently swallowed so it cannot block the
  * autofix flow.
  */
-export function reportAutofixApplied(remediationUuid, result) {
+export function reportAutofixApplied(remediationUuid, result, details) {
     const authKey = readStoredAuthKey();
     if (!authKey) {
         hookRunLog(`autofix_report: no auth key available, skipping report for uuid=${remediationUuid}`);
@@ -1267,7 +1313,15 @@ export function reportAutofixApplied(remediationUuid, result) {
     }
     const endpointBase = loadEndpointBase();
     const url = buildApiUrl(endpointBase, '/endpoint_security/api/autofix-applied/');
-    const payload = { hardware_uuid: hardwareUuid, remediation_uuid: remediationUuid, result };
+    const payload = {
+        hardware_uuid: hardwareUuid,
+        remediation_uuid: remediationUuid,
+        result,
+    };
+    if (details?.failure_reason)
+        payload.failure_reason = details.failure_reason.slice(0, 2000);
+    if (details?.consecutive_failures != null)
+        payload.consecutive_failures = details.consecutive_failures;
     const signature = createSignature(payload, authKey.key);
     const body = JSON.stringify({ ...payload, signature });
     return executeBody(url, 'POST', body, 8000)
@@ -1312,6 +1366,7 @@ export async function syncRemediations(endpointBase, machineUuid) {
         complianceRunnerDiag('remediation_sync: no response from server (non-200 or empty body), skipping');
         return;
     }
+    applyClearApplyTrackingUuids(syncResult.clear_apply_tracking_uuids);
     if (syncResult.status === 'unchanged') {
         hookRunLog(`remediation_sync: unchanged enforced=${activeUuids.length}`);
         complianceRunnerDiag(`remediation_sync: server status=unchanged local_uuids=${activeUuids.length} — no new rows to fetch; if a deploy should exist, verify Finding.machine matches this hardware_uuid`);
@@ -1345,6 +1400,7 @@ export async function syncRemediations(endpointBase, machineUuid) {
     hookRunLog(`remediation_sync: status=updated added=${added.length} removed=${removed.length}`);
     complianceRunnerDiag(`remediation_sync: server status=updated added=${JSON.stringify(added)} removed=${JSON.stringify(removed)}`);
     const removedSet = new Set(removed);
+    const retiredInstructions = remediations.filter((r) => removedSet.has(r.uuid));
     let removedCount = 0;
     remediations = remediations.filter((r) => {
         if (removedSet.has(r.uuid)) {
@@ -1398,6 +1454,7 @@ export async function syncRemediations(endpointBase, machineUuid) {
         overlay.push(instruction);
         hookRunLog(`remediation_instructions_saved: uuid=${instruction.uuid} path=${instruction.config_file_path}`);
     }
+    transferQuarantineForRetiredUuids(removed, added, retiredInstructions, overlay);
     const addedCount = overlay.length;
     if (added.length > 0 && addedCount === 0) {
         const msg = `remediation_sync: manifest had no rows for added uuids=${added.join(',')} — check server manifest/machine linkage`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "log-llm-config-staging",
-  "version": "1.3.82",
+  "version": "1.3.83",
   "description": "CLI helpers for logging hardware UUIDs and posting startup payloads to Optimus Security.",
   "type": "module",
   "bin": {