log-llm-config-staging 1.3.83 → 1.3.84

package/dist/cli.js

@@ -38,6 +38,12 @@ const main = async () => {
         await import('./compliance_check_runner.js');
         return;
     }
+    if (args[0] === 'dialog_prefs') {
+        const { runDialogPrefsCli } = await import('./dialog_prefs_cli.js');
+        await runDialogPrefsCli();
+        process.exit(0);
+        return;
+    }
     // `npx log-llm-config@latest <name>` runs this file (default bin) with args[0] set — not the named bin file.
     if (args[0] === 'execute-trusted-restarts') {
         const { runExecuteTrustedRestartsFromStdin } = await import('./execute_trusted_restarts.js');

package/dist/compliance_prompt_gate.js

@@ -6,10 +6,10 @@
  * 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, reportPostRestartVerificationOutcomes, runLocalRemediationComplianceCheck, } from './log_config_files/runtime/compliance_check.js';
-import { isRemediationQuarantined } from './log_config_files/runtime/remediation_apply_tracking.js';
+import { applyAutofixViolations, normalizeAgentToken, pruneSatisfiedOneTimeRemediations, reportPostRestartVerificationOutcomes, runLocalRemediationComplianceCheck, uploadSatisfiedManifestConfigs, } from './log_config_files/runtime/compliance_check.js';
+import { isRemediationQuarantined, markRemediationApplyVerified, } 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 { getRemediationInstructionsPath } from './log_config_files/runtime/management_storage.js';
 import { hookLogSessionBanner, hookRunLog, logRemediationApplyFailure } from './log_config_files/runtime/hook_logger.js';
 import { isThisCliModule } from './cli_invocation_match.js';
 import { ensureAuthentication } from './log_config_files/auth/auth_flow.js';
@@ -17,6 +17,7 @@ import { sendConfigFile } from './log_config_files/sender/batch_sender.js';
 import { tryResolveHardwareUuid } from './log_config_files/runtime/hardware_uuid.js';
 import { syncRemediations } from './log_config_files/runtime/remediation_sync.js';
 import { loadEndpointBase } from './log_config_files/sender/endpoint_config.js';
+import { formatRemediationChangePreviewForApplied } from './remediation_change_preview.js';
 const MANIFEST_STALE_MS = 7 * 24 * 60 * 60 * 1000;
 function parseIde() {
     const eq = process.argv.find((a) => a.startsWith('--ide='));
@@ -103,8 +104,11 @@ function uniquePolicyLabelsFromViolations(appliedViolations) {
     return policyNames.length > 0 ? policyNames.join('\n\n') : 'Agent security policy';
 }
 function formatPreventiveAutofixDialog(appliedViolations, applyLine) {
+    const changePreview = formatRemediationChangePreviewForApplied(appliedViolations);
+    const changePreviewBlock = changePreview ? `${changePreview}\n\n` : '';
     return ('Optimus Labs enforced a preventive agent security policy as determined by your security team:\n\n' +
         `${uniquePolicyLabelsFromViolations(appliedViolations)}\n\n` +
+        changePreviewBlock +
         `${applyLine}\n\n` +
         'Click OK to continue');
 }
@@ -166,17 +170,14 @@ export async function runCompliancePromptGate() {
     // unavailable server never delays the gate significantly.
     const hw = tryResolveHardwareUuid();
     if (hw) {
-        const { remediations } = readRemediationInstructionsFile();
-        if (Array.isArray(remediations) && remediations.length > 0) {
-            try {
-                await Promise.race([
-                    syncRemediations(loadEndpointBase(), hw),
-                    new Promise((resolve) => setTimeout(resolve, 3000)),
-                ]);
-            }
-            catch {
-                // Network or auth failure — fall back to local file state.
-            }
+        try {
+            await Promise.race([
+                syncRemediations(loadEndpointBase(), hw),
+                new Promise((resolve) => setTimeout(resolve, 3000)),
+            ]);
+        }
+        catch {
+            // Network or auth failure — fall back to local file state.
         }
     }
     const status = runLocalRemediationComplianceCheck(agent);
@@ -248,13 +249,22 @@ export async function runCompliancePromptGate() {
                 hookRunLog('compliance_prompt_gate: Claude — autofix wrote JSON; recheck still flags same UUID(s) — proceeding (immediate apply)');
             }
             if (deferredSqlitePending || recheckOk || claudeRecheckStaleAfterImmediateApply) {
+                // For immediate (non-restart, non-deferred) fixes that the inline recheck confirmed,
+                // mark verified now so the next hook run does not false-quarantine due to pending flag.
+                if (recheckOk && restartCommands.length === 0 && !deferredSqlitePending) {
+                    for (const v of appliedViolations) {
+                        markRemediationApplyVerified(v.uuid);
+                    }
+                }
+                const changePreview = formatRemediationChangePreviewForApplied(appliedViolations);
+                const changePreviewSuffix = changePreview ? `\n\n${changePreview}` : '';
                 const autofixMessage = ide === 'cursor' && restartCommands.length > 0
                     ? formatCursorRestartAutofixDialog(appliedViolations)
                     : ide === 'claude'
                         ? formatClaudeAutofixDialog(appliedViolations)
                         : `Optimus Labs auto-fixed ${fixed} ${fixed === 1 ? 'policy violation' : 'policy violations'}:\n\n${appliedViolations
                             .map((v) => autofixDialogLine(v))
-                            .join('\n')}`;
+                            .join('\n')}${changePreviewSuffix}`;
                 const payload = { __optimus_autofix: true, autofix_message: autofixMessage };
                 if (restartCommands.length > 0)
                     payload.restart_commands = restartCommands;
@@ -300,6 +310,7 @@ export async function runCompliancePromptGate() {
     if (pruned.removed > 0) {
         await Promise.allSettled(pruned.reportPromises);
     }
+    await Promise.allSettled(uploadSatisfiedManifestConfigs(agent));
     printAllow(ide);
 }
 if (isRunAsCliModule()) {

package/dist/dialog_prefs_cli.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/**
+ * CLI for macOS non-restart autofix dialogs and dialog preferences in ~/opt-ai-sec/management.
+ * Invoked from optimus-compliance-check.sh hooks.
+ */
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { isNonRestartAutofixDialogSuppressed, setSuppressNonRestartAutofixDialogs, } from './log_config_files/runtime/dialog_preferences.js';
+export const STOP_NOTIFICATIONS_BUTTON = 'Mute Alerts';
+export const OK_BUTTON = 'OK';
+function cliParts() {
+    const a = process.argv;
+    if (a[2] === 'dialog_prefs')
+        return a.slice(2);
+    return a.slice(2);
+}
+function parseArgValue(parts, flag) {
+    const eq = parts.find((p) => p.startsWith(`${flag}=`));
+    if (eq)
+        return eq.slice(flag.length + 1);
+    const idx = parts.indexOf(flag);
+    if (idx >= 0 && parts[idx + 1])
+        return parts[idx + 1];
+    return undefined;
+}
+function escapeAppleScriptString(text) {
+    return text.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+function icnsIconClause() {
+    const p = (process.env.OPTIMUS_DIALOG_ICNS ?? '').trim();
+    if (!p || !existsSync(p))
+        return 'with icon caution';
+    try {
+        const buf = readFileSync(p);
+        if (buf.length < 8 || buf.subarray(0, 4).toString('ascii') !== 'icns') {
+            return 'with icon caution';
+        }
+    }
+    catch {
+        return 'with icon caution';
+    }
+    return `with icon POSIX file "${escapeAppleScriptString(p)}"`;
+}
+export function buildNonRestartAutofixDialogScript(message, target) {
+    const msg = escapeAppleScriptString(message);
+    const icon = icnsIconClause();
+    const mute = escapeAppleScriptString(STOP_NOTIFICATIONS_BUTTON);
+    const body = `display dialog "${msg}" with title "Optimus Labs" buttons {"${mute}", "${OK_BUTTON}"} default button "${OK_BUTTON}" ${icon}`;
+    if (target === 'cursor') {
+        return `tell application "Cursor" to ${body}`;
+    }
+    if (target === 'claude-app') {
+        return `tell application "Claude" to ${body}`;
+    }
+    return body;
+}
+export function showNonRestartAutofixDialog(message, target) {
+    const script = buildNonRestartAutofixDialogScript(message, target);
+    let out = '';
+    try {
+        out = execFileSync('osascript', ['-'], { input: script, encoding: 'utf8' });
+    }
+    catch (err) {
+        const e = err;
+        out = typeof e.stdout === 'string' ? e.stdout : '';
+        // User dismissed or osascript failed — do not block callers; preference only set on explicit Stop.
+        if (!out.includes(STOP_NOTIFICATIONS_BUTTON)) {
+            throw err;
+        }
+    }
+    if (out.includes(STOP_NOTIFICATIONS_BUTTON)) {
+        setSuppressNonRestartAutofixDialogs(true);
+        return 'stop_notifications';
+    }
+    return 'ok';
+}
+function readMessageFile(path) {
+    if (!path || !existsSync(path)) {
+        throw new Error(`message file not found: ${path}`);
+    }
+    return readFileSync(path, 'utf8');
+}
+export async function runDialogPrefsCli() {
+    const parts = cliParts();
+    const sub = parts[1];
+    if (sub === 'is_suppressed') {
+        console.log(isNonRestartAutofixDialogSuppressed() ? 'true' : 'false');
+        return;
+    }
+    if (sub === 'set_suppress') {
+        setSuppressNonRestartAutofixDialogs(true);
+        return;
+    }
+    if (sub === 'show') {
+        const messageFile = parseArgValue(parts, '--message-file');
+        const targetRaw = parseArgValue(parts, '--target') ?? 'terminal';
+        if (targetRaw !== 'cursor' && targetRaw !== 'claude-app' && targetRaw !== 'terminal') {
+            throw new Error(`invalid --target: ${targetRaw}`);
+        }
+        const message = readMessageFile(messageFile ?? '');
+        showNonRestartAutofixDialog(message, targetRaw);
+        return;
+    }
+    throw new Error(`unknown dialog_prefs subcommand: ${sub ?? '(none)'}`);
+}

package/dist/log_config_files/runtime/compliance_check.js

@@ -16,7 +16,8 @@ import { join } from 'node:path';
 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 { resolveOpsTargetPath } from './ops_target_path.js';
+import { isRemediationQuarantined, markRemediationApplyPendingVerification, processPendingPostRestartVerifications, readRemediationApplyTrackingFile, writeRemediationApplyTrackingFile, } 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';
@@ -166,13 +167,8 @@ function verifyOpsApplied(configJson, settingPath, ops) {
     const add = ops.add ?? {};
     const remove = ops.remove ?? {};
     const keys = new Set([...Object.keys(set), ...Object.keys(add), ...Object.keys(remove)]);
-    // If ops targets a single leaf key, check at settingPath; otherwise treat keys as subkeys under parent.
     for (const k of keys) {
-        const targetPath = k === leafKey || (keys.size === 1 && (k === leafKey || k === ''))
-            ? settingPath
-            : parentPath
-                ? `${parentPath}.${k}`
-                : k;
+        const targetPath = resolveOpsTargetPath(settingPath, k);
         if (Object.prototype.hasOwnProperty.call(set, k)) {
             const cur = getByPath(configJson, targetPath);
             const expected = set[k];
@@ -770,6 +766,68 @@ export function pruneSatisfiedOneTimeRemediations(agent = 'cursor') {
     }
     return { removed, reportPromises };
 }
+/** Throttle satisfied-manifest uploads (disk already matches ops; autofix did not run). */
+const SATISFIED_MANIFEST_UPLOAD_COOLDOWN_MS = 5 * 60 * 1000;
+/**
+ * When local compliance already passes, autofix is skipped — so settings never reach the server.
+ * Upload satisfied JSON remediations (throttled) so scan can resolve findings.
+ */
+export function uploadSatisfiedManifestConfigs(agent = 'cursor') {
+    const { remediations } = readRemediationInstructionsFile();
+    const entries = remediations.filter((e) => targetsCurrentAgent(e, agent));
+    const promises = [];
+    for (const entry of entries) {
+        const { violations } = evaluateManifestEntryCompliance(entry);
+        if (violations.length > 0)
+            continue;
+        const inst = entry;
+        const fileType = (inst.file_type ?? '').trim();
+        if (!fileType)
+            continue;
+        const diskPath = resolveRemediationConfigPath(entry.config_file_path);
+        if (diskPath.includes('#'))
+            continue;
+        const tracking = readRemediationApplyTrackingFile();
+        const prev = tracking.entries[entry.uuid];
+        const lastUpload = prev?.last_satisfied_upload_at;
+        if (lastUpload) {
+            const elapsed = Date.now() - Date.parse(lastUpload);
+            if (!Number.isNaN(elapsed) && elapsed < SATISFIED_MANIFEST_UPLOAD_COOLDOWN_MS) {
+                continue;
+            }
+        }
+        let rawContent;
+        try {
+            rawContent = JSON.parse(readFileSync(diskPath, 'utf8'));
+        }
+        catch {
+            hookRunLog(`satisfied_upload: could not read path=${diskPath} uuid=${entry.uuid}`);
+            continue;
+        }
+        const hw = tryResolveHardwareUuid();
+        if (!hw) {
+            hookRunLog(`satisfied_upload: skip uuid=${entry.uuid} (hardware UUID unavailable)`);
+            continue;
+        }
+        const uploadPath = entry.config_file_path.trim() || diskPath;
+        promises.push(ensureAuthentication(hw)
+            .then((authKey) => sendConfigFile({ file_type: fileType, file_path: uploadPath, raw_content: rawContent }, hw, authKey))
+            .then((sentOk) => {
+            hookRunLog(`satisfied_upload: uuid=${entry.uuid} path=${uploadPath} ok=${sentOk}`);
+            if (sentOk) {
+                const file = readRemediationApplyTrackingFile();
+                const ent = file.entries[entry.uuid] ?? { consecutive_verify_failures: 0, quarantined: false };
+                ent.last_satisfied_upload_at = new Date().toISOString();
+                file.entries[entry.uuid] = ent;
+                writeRemediationApplyTrackingFile(file);
+            }
+        })
+            .catch((err) => {
+            hookRunLog(`satisfied_upload: failed uuid=${entry.uuid} err=${err instanceof Error ? err.message : String(err)}`);
+        }));
+    }
+    return promises;
+}
 /**
  * Background refresh: server sync for latest instructions, then the same local evaluation as the hook.
  * Apply (autofix) is intentionally deferred to the gate on the next prompt — this pass only downloads
@@ -789,5 +847,6 @@ export async function runComplianceCheck() {
         if (pruned.removed > 0) {
             await Promise.allSettled(pruned.reportPromises);
         }
+        await Promise.allSettled(uploadSatisfiedManifestConfigs(agent));
     }
 }

package/dist/log_config_files/runtime/dialog_preferences.js

@@ -0,0 +1,31 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { atomicWriteJson, getDialogPreferencesPath, } from './management_storage.js';
+export function readDialogPreferences() {
+    const path = getDialogPreferencesPath();
+    if (!existsSync(path)) {
+        return { version: 1, suppress_non_restart_autofix_dialogs: false };
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        if (parsed?.version !== 1)
+            return { version: 1, suppress_non_restart_autofix_dialogs: false };
+        return {
+            version: 1,
+            suppress_non_restart_autofix_dialogs: Boolean(parsed.suppress_non_restart_autofix_dialogs),
+        };
+    }
+    catch {
+        return { version: 1, suppress_non_restart_autofix_dialogs: false };
+    }
+}
+export function isNonRestartAutofixDialogSuppressed() {
+    return readDialogPreferences().suppress_non_restart_autofix_dialogs === true;
+}
+export function setSuppressNonRestartAutofixDialogs(suppress) {
+    const next = {
+        version: 1,
+        suppress_non_restart_autofix_dialogs: suppress,
+        updated_at: new Date().toISOString(),
+    };
+    atomicWriteJson(getDialogPreferencesPath(), next);
+}

package/dist/log_config_files/runtime/management_storage.js

@@ -17,6 +17,8 @@ export const DEFERRED_VSCDB_RESTART_LOG_BASENAME = 'deferred_vscdb_restart.log';
  * of hardcoded Cursor paths.
  */
 export const FILE_COLLECTION_VSCDB_CONTRACT_BASENAME = 'file_collection_vscdb_contract.json';
+/** User preferences for Optimus macOS dialogs (hook-driven). */
+export const DIALOG_PREFERENCES_BASENAME = 'optimus_dialog_preferences.json';
 export function sanitizeReactiveStorageItemKey(raw) {
     if (typeof raw !== 'string')
         return undefined;
@@ -59,6 +61,9 @@ export function getDeferredVscdbRestartLogPath() {
 export function getFileCollectionVscdbContractPath() {
     return join(getManagementDir(), FILE_COLLECTION_VSCDB_CONTRACT_BASENAME);
 }
+export function getDialogPreferencesPath() {
+    return join(getManagementDir(), DIALOG_PREFERENCES_BASENAME);
+}
 export function readFileCollectionVscdbContract() {
     const path = getFileCollectionVscdbContractPath();
     if (!existsSync(path))

package/dist/log_config_files/runtime/ops_target_path.js

@@ -0,0 +1,18 @@
+/**
+ * Map ops.add/set/remove keys to JSON dot-paths for apply + verify.
+ *
+ * Server may use either the leaf key (e.g. `deny`) or the full setting_path
+ * (e.g. `cursor.general.globalCursorIgnoreList`) as the op map key.
+ */
+export function resolveOpsTargetPath(settingPath, opKey) {
+    const parts = settingPath.split('.');
+    const leafKey = parts[parts.length - 1] ?? '';
+    const parentPath = parts.slice(0, -1).join('.');
+    if (opKey === settingPath || opKey === leafKey) {
+        return settingPath;
+    }
+    if (opKey.includes('.')) {
+        return opKey;
+    }
+    return parentPath ? `${parentPath}.${opKey}` : opKey;
+}

package/dist/log_config_files/runtime/remediation_config_path.js

@@ -6,6 +6,30 @@ import { join } from 'node:path';
  * (see optimus_security/endpoint/log_config_file/handler._canonical_cursor_user_state_vscdb_path).
  */
 export const PORTABLE_CURSOR_USER_STATE_VSCDB = 'Cursor/User/globalStorage/state.vscdb';
+/** Portable key for Cursor User settings.json (globalCursorIgnoreList). */
+export const PORTABLE_CURSOR_USER_SETTINGS = 'Cursor/User/settings.json';
+function expandLeadingTilde(configFilePath) {
+    const t = configFilePath.trim();
+    if (t.startsWith('~/')) {
+        return join(homedir(), t.slice(2));
+    }
+    return configFilePath;
+}
+function cursorUserSettingsAbsolutePaths() {
+    const h = homedir();
+    if (process.platform === 'darwin') {
+        const support = join(h, 'Library', 'Application Support');
+        const variants = ['Cursor', 'Cursor - Insiders', 'Cursor Nightly', 'Cursor Next'];
+        return variants.map((name) => join(support, name, 'User', 'settings.json'));
+    }
+    if (process.platform === 'win32') {
+        const appData = process.env.APPDATA;
+        if (appData)
+            return [join(appData, 'Cursor', 'User', 'settings.json')];
+        return [join(h, 'AppData', 'Roaming', 'Cursor', 'User', 'settings.json')];
+    }
+    return [join(h, '.config', 'Cursor', 'User', 'settings.json')];
+}
 function normalizeSlashes(p) {
     return p.trim().replace(/\\/g, '/');
 }
@@ -74,13 +98,23 @@ function cursorStateVscdbAbsoluteBasePaths() {
  * No-op for absolute paths and for relative paths that are not the portable vscdb key.
  */
 export function resolveRemediationConfigPath(configFilePath) {
-    const t = normalizeSlashes(configFilePath);
+    const expandedTilde = expandLeadingTilde(configFilePath);
+    const t = normalizeSlashes(expandedTilde);
     const hash = t.indexOf('#');
     const base = hash >= 0 ? t.slice(0, hash) : t;
     const frag = hash >= 0 ? t.slice(hash) : '';
     const baseNorm = base.replace(/\/+$/, '');
     if (baseNorm.startsWith('/') || /^[a-zA-Z]:\//.test(baseNorm)) {
-        return configFilePath;
+        return expandedTilde;
+    }
+    const portableSettings = PORTABLE_CURSOR_USER_SETTINGS;
+    if (baseNorm === portableSettings || baseNorm.endsWith('/' + portableSettings)) {
+        const candidates = cursorUserSettingsAbsolutePaths();
+        for (const abs of candidates) {
+            if (existsSync(abs))
+                return abs;
+        }
+        return candidates[0];
     }
     const portable = PORTABLE_CURSOR_USER_STATE_VSCDB;
     if (baseNorm !== portable && !baseNorm.endsWith('/' + portable)) {

package/dist/log_config_files/runtime/remediation_sync.js

@@ -2,10 +2,11 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, rename
 import { delimiter, dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 import { execFileSync } from 'node:child_process';
-import { executeGet, executeBody } from '../../endpoint_client/http_transport.js';
+import { executeBody } from '../../endpoint_client/http_transport.js';
 import { complianceRunnerDiag, hookRunLog, logRemediationApplyFailure } from './hook_logger.js';
 import { atomicWriteJson, getDeferredVscdbApplyPath, getFileCollectionVscdbContractPath, getRemediationInstructionsPath, readRemediationInstructionsFile, writeRemediationInstructionsFile, } from './management_storage.js';
 import { readStoredAuthKey } from '../auth/auth_key_store.js';
+import { ensureAuthentication } from '../auth/auth_flow.js';
 import { createSignature } from '../sender/signing.js';
 import { loadEndpointBase } from '../sender/endpoint_config.js';
 import { tryResolveHardwareUuid } from './hardware_uuid.js';
@@ -16,6 +17,7 @@ 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 { resolveOpsTargetPath } from './ops_target_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';
@@ -156,38 +158,95 @@ function transferQuarantineForRetiredUuids(removed, added, retiredInstructions,
     if (changed)
         writeRemediationApplyTrackingFile(file);
 }
+async function ensureAuthKeyForMachine(machineUuid) {
+    const stored = readStoredAuthKey();
+    if (stored?.key)
+        return stored;
+    try {
+        return await ensureAuthentication(machineUuid);
+    }
+    catch (err) {
+        hookRunLog(`remediation_sync: ensureAuthentication failed: ${err instanceof Error ? err.message : String(err)}`);
+        complianceRunnerDiag(`remediation_sync: ensureAuthentication failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+function buildSignedMachinePostBody(machineUuid, fields, authKey) {
+    const payload = { machine_uuid: machineUuid, ...fields };
+    const signature = createSignature(payload, authKey.key);
+    return JSON.stringify({ ...payload, signature });
+}
 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)}`;
-    const { statusCode, body } = await executeGet(url, timeoutMs);
-    if (statusCode !== 200 || !body) {
-        const line = `remediation_sync_get: url=${url} status=${statusCode} bytes=${body?.length ?? 0}`;
+    const sortedUuids = [...new Set(activeUuids.map((u) => u.trim()).filter(Boolean))].sort();
+    const authKey = await ensureAuthKeyForMachine(machineUuid);
+    if (!authKey) {
+        hookRunLog('remediation_sync_post: no auth key, skipping');
+        complianceRunnerDiag('remediation_sync_post: no auth key');
+        return null;
+    }
+    const url = buildApiUrl(endpointBase, '/api/findings/remediations/sync/');
+    const body = buildSignedMachinePostBody(machineUuid, { active_uuids: sortedUuids }, authKey);
+    let statusCode = 0;
+    let responseBody = '';
+    try {
+        const result = await executeBody(url, 'POST', body, timeoutMs);
+        statusCode = result.statusCode;
+        responseBody = result.body;
+    }
+    catch (err) {
+        const line = `remediation_sync_post: url=${url} error=${err instanceof Error ? err.message : String(err)}`;
+        hookRunLog(line);
+        complianceRunnerDiag(line);
+        return null;
+    }
+    if (statusCode !== 200 || !responseBody) {
+        const line = `remediation_sync_post: url=${url} status=${statusCode} bytes=${responseBody?.length ?? 0}`;
         hookRunLog(line);
         complianceRunnerDiag(line);
         return null;
     }
     try {
-        return JSON.parse(body);
+        return JSON.parse(responseBody);
     }
     catch {
-        hookRunLog('remediation_sync_get: invalid JSON body');
-        complianceRunnerDiag('remediation_sync_get: invalid JSON body');
+        hookRunLog('remediation_sync_post: invalid JSON body');
+        complianceRunnerDiag('remediation_sync_post: invalid JSON body');
         return null;
     }
 }
 async function fetchManifest(endpointBase, machineUuid, uuids, timeoutMs = 8000) {
-    const url = `${buildApiUrl(endpointBase, '/api/findings/remediations/manifest/')}?machine_uuid=${encodeURIComponent(machineUuid)}&uuids=${encodeURIComponent(uuids.join(','))}`;
-    const { statusCode, body } = await executeGet(url, timeoutMs);
-    if (statusCode !== 200 || !body) {
-        const line = `remediation_manifest_get: url=${url} status=${statusCode} bytes=${body?.length ?? 0}`;
+    const sortedUuids = [...new Set(uuids.map((u) => u.trim()).filter(Boolean))].sort();
+    const authKey = await ensureAuthKeyForMachine(machineUuid);
+    if (!authKey) {
+        hookRunLog('remediation_manifest_post: no auth key, skipping');
+        complianceRunnerDiag('remediation_manifest_post: no auth key');
+        return null;
+    }
+    const url = buildApiUrl(endpointBase, '/api/findings/remediations/manifest/');
+    const body = buildSignedMachinePostBody(machineUuid, { uuids: sortedUuids }, authKey);
+    let statusCode = 0;
+    let responseBody = '';
+    try {
+        const result = await executeBody(url, 'POST', body, timeoutMs);
+        statusCode = result.statusCode;
+        responseBody = result.body;
+    }
+    catch (err) {
+        const line = `remediation_manifest_post: url=${url} error=${err instanceof Error ? err.message : String(err)}`;
+        hookRunLog(line);
+        complianceRunnerDiag(line);
+        return null;
+    }
+    if (statusCode !== 200 || !responseBody) {
+        const line = `remediation_manifest_post: url=${url} status=${statusCode} bytes=${responseBody?.length ?? 0}`;
         hookRunLog(line);
         complianceRunnerDiag(line);
         return null;
     }
     try {
-        const parsed = JSON.parse(body);
+        const parsed = JSON.parse(responseBody);
         if (!Array.isArray(parsed.remediations)) {
-            complianceRunnerDiag('remediation_manifest_get: JSON remediations is not an array');
+            complianceRunnerDiag('remediation_manifest_post: JSON remediations is not an array');
             return null;
         }
         return parsed.remediations.map((raw) => {
@@ -197,7 +256,7 @@ async function fetchManifest(endpointBase, machineUuid, uuids, timeoutMs = 8000)
         });
     }
     catch {
-        complianceRunnerDiag('remediation_manifest_get: invalid JSON body');
+        complianceRunnerDiag('remediation_manifest_post: invalid JSON body');
         return null;
     }
 }
@@ -308,11 +367,7 @@ function applyCheck(configJson, check) {
             ...Object.keys(remove ?? {}),
         ]);
         for (const k of keys) {
-            const targetPath = k === leafKey || keys.size === 1 && (k === leafKey || k === '')
-                ? check.setting_path
-                : parentPath
-                    ? `${parentPath}.${k}`
-                    : k;
+            const targetPath = resolveOpsTargetPath(check.setting_path, k);
             if (set && Object.prototype.hasOwnProperty.call(set, k)) {
                 setByPath(configJson, targetPath, set[k]);
                 continue;
@@ -431,7 +486,11 @@ const TRUSTED_CURSOR_SQLITE_DEFERRED_RESTART_COMMAND = 'REPO_ROOT=$(git rev-pars
     'CURSOR_PROJECT="${CURSOR_PROJECT_DIR:-$REPO_ROOT}" && export CURSOR_PROJECT && ' +
     'OPTIMUS_DEFERRED_LOG="${HOME}/opt-ai-sec/management/deferred_vscdb_restart.log" && mkdir -p "$(dirname "$OPTIMUS_DEFERRED_LOG")" && export OPTIMUS_DEFERRED_LOG && ' +
     "nohup bash -c 'exec >>\"\$OPTIMUS_DEFERRED_LOG\" 2>&1; echo deferred_restart:begin ts=\$(date -u +%Y-%m-%dT%H:%M:%SZ) REPO_ROOT=\"\$REPO_ROOT\" CURSOR_PROJECT=\"\$CURSOR_PROJECT\"; sleep 2; STATIC_DEV_ENV=\"\$HOME/opt-ai-sec/management/optimus_dev.env\"; ENV_LABEL=\"\"; if [ -f \"\$STATIC_DEV_ENV\" ]; then ENV_LABEL=\$(grep -E \"^(environment|ENVIRONMENT|OPTIMUS_ENVIRONMENT)=\" \"\$STATIC_DEV_ENV\" 2>/dev/null | head -1 | cut -d\"=\" -f2- | tr \"[:upper:]\" \"[:lower:]\" | xargs); fi; if [ -z \"\$ENV_LABEL\" ] && [ -n \"\${OPTIMUS_ENVIRONMENT:-}\" ]; then ENV_LABEL=\$(printf \"%s\" \"\$OPTIMUS_ENVIRONMENT\" | tr \"[:upper:]\" \"[:lower:]\" | xargs); fi; [ -z \"\$ENV_LABEL\" ] && ENV_LABEL=\"production\"; NPX_BASE=\"\"; if [ -f \"\$STATIC_DEV_ENV\" ]; then _nb=\$(grep -E \"^npx=\" \"\$STATIC_DEV_ENV\" 2>/dev/null | head -1 | cut -d\"=\" -f2- | xargs); [ -n \"\$_nb\" ] && [ -d \"\$_nb\" ] && NPX_BASE=\"\$_nb\"; fi; p=\"\${npm_config_prefix:-\${NPM_CONFIG_PREFIX:-}}\"; gp=\"\${npm_config_global_prefix:-}\"; gc=\"\${npm_config_globalconfig:-}\"; if [[ \"\$p\" == *\"/Applications/Cursor.app/\"* ]] || [[ \"\$gp\" == *\"/Applications/Cursor.app/\"* ]] || [[ \"\$gc\" == *\"/Applications/Cursor.app/\"* ]]; then unset npm_config_prefix NPM_CONFIG_PREFIX npm_config_global_prefix npm_config_globalconfig npm_node_execpath 2>/dev/null; fi; APPLY_EC=0; if [ -f \"\$REPO_ROOT/dev_npx_packages/log-llm-config/dist/apply_deferred_vscdb.js\" ]; then echo deferred_restart:apply_via_dev_npx_packages; node \"\$REPO_ROOT/dev_npx_packages/log-llm-config/dist/apply_deferred_vscdb.js\"; APPLY_EC=\$?; elif [ \"\$ENV_LABEL\" = \"development\" ] && [ -n \"\$NPX_BASE\" ] && [ -f \"\$NPX_BASE/log-llm-config/dist/apply_deferred_vscdb.js\" ]; then echo deferred_restart:apply_via_optimus_npx_base; node \"\$NPX_BASE/log-llm-config/dist/apply_deferred_vscdb.js\"; APPLY_EC=\$?; elif command -v npx >/dev/null 2>&1; then echo deferred_restart:apply_via_npx env=\"\$ENV_LABEL\"; cd \"\$REPO_ROOT\" || true; if [ \"\$ENV_LABEL\" = \"staging\" ]; then npx --yes --package=log-llm-config-staging@latest apply-deferred-vscdb-staging; APPLY_EC=\$?; else npx --yes --package=log-llm-config@latest apply-deferred-vscdb; APPLY_EC=\$?; fi; else echo deferred_restart:no_npx; APPLY_EC=127; fi; echo deferred_restart:apply_exit=\$APPLY_EC; if [ \$APPLY_EC -ne 0 ]; then echo deferred_restart:APPLY_FAILED_see_messages_above; fi; echo deferred_restart:open_cursor; env -u npm_config_package -u npm_lifecycle_event -u npm_lifecycle_script -u npm_config_local_prefix open -a Cursor \"\$CURSOR_PROJECT\"; echo deferred_restart:open_exit=\$?; echo deferred_restart:end ts=\$(date -u +%Y-%m-%dT%H:%M:%SZ)' >/dev/null 2>&1 & killall -9 Cursor";
-const TRUSTED_CURSOR_JSON_SETTINGS_RESTART_COMMAND = 'CURSOR_PROJECT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) && export CURSOR_PROJECT && nohup bash -c \'sleep 2 && open -a Cursor "$CURSOR_PROJECT"\' >/dev/null 2>&1 & killall -9 Cursor';
+/** Legacy manifests; hooks may run with cwd under `.cursor` where `pwd` is wrong. */
+const TRUSTED_CURSOR_JSON_SETTINGS_RESTART_COMMAND_LEGACY = 'CURSOR_PROJECT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) && export CURSOR_PROJECT && nohup bash -c \'sleep 2 && open -a Cursor "$CURSOR_PROJECT"\' >/dev/null 2>&1 & killall -9 Cursor';
+const TRUSTED_CURSOR_JSON_SETTINGS_RESTART_COMMAND = 'REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd) && export REPO_ROOT && ' +
+    'CURSOR_PROJECT="${CURSOR_PROJECT_DIR:-$REPO_ROOT}" && export CURSOR_PROJECT && ' +
+    "nohup bash -c 'sleep 2 && open -a Cursor \"$CURSOR_PROJECT\"' >/dev/null 2>&1 & killall -9 Cursor";
 const TRUSTED_CLAUDE_RESTART_COMMAND = "nohup bash -c 'sleep 2 && open -a Claude' >/dev/null 2>&1 & pkill -x 'Claude'";
 export function isClaudeRestartCommand(cmd) {
     return cmd.trim() === TRUSTED_CLAUDE_RESTART_COMMAND;
@@ -439,7 +498,8 @@ export function isClaudeRestartCommand(cmd) {
 export function isCursorRestartCommand(cmd) {
     const t = cmd.trim();
     return (t === TRUSTED_CURSOR_SQLITE_DEFERRED_RESTART_COMMAND ||
-        t === TRUSTED_CURSOR_JSON_SETTINGS_RESTART_COMMAND);
+        t === TRUSTED_CURSOR_JSON_SETTINGS_RESTART_COMMAND ||
+        t === TRUSTED_CURSOR_JSON_SETTINGS_RESTART_COMMAND_LEGACY);
 }
 /**
  * Autofix restart_command allowlist: manifest strings are attacker-controlled if JSON is tampered.
@@ -452,6 +512,7 @@ export function isTrustedRestartCommandForAutofix(cmd) {
         return false;
     return (t === TRUSTED_CURSOR_SQLITE_DEFERRED_RESTART_COMMAND ||
         t === TRUSTED_CURSOR_JSON_SETTINGS_RESTART_COMMAND ||
+        t === TRUSTED_CURSOR_JSON_SETTINGS_RESTART_COMMAND_LEGACY ||
         t === TRUSTED_CLAUDE_RESTART_COMMAND);
 }
 /** Legacy Cursor: dedicated ItemTable row `composerState`. Current Cursor: nested under reactive `applicationUser` blob. */
@@ -927,6 +988,9 @@ export function buildDeferredCursorRestartCommand() {
     // (package bin) so published installs work without a local dev_npx_packages copy.
     return TRUSTED_CURSOR_SQLITE_DEFERRED_RESTART_COMMAND;
 }
+export function buildCursorJsonSettingsRestartCommand() {
+    return TRUSTED_CURSOR_JSON_SETTINGS_RESTART_COMMAND;
+}
 function sqliteRowGroupKey(dbPath, op) {
     return `${dbPath}|${op.table}|${op.key_column}|${op.value_column}|${op.target_key}`;
 }

package/dist/log_config_files/runtime/trusted_restarts.js

@@ -7,6 +7,7 @@ import { appendComplianceRunnerLine, hookRunLog } from './hook_logger.js';
 import { getDeferredVscdbRestartLogPath } from './management_storage.js';
 import { normalizeAgentToken } from './compliance_check.js';
 import { isClaudeRestartCommand, isCursorRestartCommand, isTrustedRestartCommandForAutofix } from './remediation_sync.js';
+import { resolveProjectRoot } from './workspace_repo.js';
 const FALLBACK_PATH = '/usr/bin:/bin:/usr/local/bin:/opt/homebrew/bin';
 /** Vars set by `npx --package=...` that break unrelated scoped `npx @scope/pkg` after Cursor reopen. */
 const NPM_RESTART_POLLUTION = [
@@ -72,11 +73,14 @@ export function executeTrustedRestartCommands(commands) {
             hookRunLog('execute_trusted_restarts: spawning trusted restart (see compliance_runner.log [RESTART])');
             appendComplianceRunnerLine('RESTART', 'spawn trusted_restart sh -c (non-deferred)');
         }
+        const projectRoot = resolveProjectRoot();
         const child = spawn('sh', ['-c', t], {
             detached: true,
             stdio: 'ignore',
+            cwd: projectRoot,
             env: envForRestartSpawn({
                 ...process.env,
+                CURSOR_PROJECT_DIR: process.env.CURSOR_PROJECT_DIR || projectRoot,
                 PATH: process.env.PATH && String(process.env.PATH).trim().length > 0
                     ? process.env.PATH
                     : FALLBACK_PATH,

package/dist/remediation_change_preview.js

@@ -0,0 +1,182 @@
+import { readRemediationInstructionsFile } from './log_config_files/runtime/management_storage.js';
+import { remediationFixSpec } from './log_config_files/runtime/remediation_sync.js';
+export const MAX_PREVIEW_LINES = 5;
+export const MAX_PREVIEW_LINE_CHARS = 72;
+function truncateLine(text, max = MAX_PREVIEW_LINE_CHARS) {
+    const trimmed = text.trim();
+    if (trimmed.length <= max)
+        return trimmed;
+    return `${trimmed.slice(0, max - 1)}…`;
+}
+function formatScalar(value) {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    if (typeof value === 'string')
+        return `"${value}"`;
+    if (typeof value === 'boolean' || typeof value === 'number')
+        return String(value);
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return '[]';
+        const parts = value.slice(0, 2).map((entry) => formatScalar(entry));
+        if (value.length > 2)
+            return `${parts.join(', ')} …+${value.length - 2}`;
+        return parts.join(', ');
+    }
+    if (typeof value === 'object') {
+        const record = value;
+        if (typeof record.serverName === 'string')
+            return `"${record.serverName}"`;
+        const keys = Object.keys(record);
+        if (keys.length === 1 && keys[0])
+            return formatScalar(record[keys[0]]);
+        if (keys.length <= 3)
+            return `{${keys.join(', ')}}`;
+        return `{${keys.slice(0, 2).join(', ')}, …}`;
+    }
+    return String(value);
+}
+function formatListDeltaItems(items) {
+    if (items.length === 0)
+        return '—';
+    const shown = items.slice(0, 2).map((entry) => formatScalar(entry));
+    if (items.length > 2)
+        return `${shown.join(', ')} …+${items.length - 2}`;
+    return shown.join(', ');
+}
+function leafFromSettingPath(settingPath, opKey) {
+    const path = settingPath.trim();
+    if (!path)
+        return opKey;
+    if (path.endsWith(`.${opKey}`))
+        return opKey;
+    const last = path.split('.').pop();
+    return last && last.length > 0 ? last : opKey;
+}
+function linesFromOps(check) {
+    const lines = [];
+    const settingPath = check.setting_path ?? '';
+    const ops = check.ops;
+    if (!ops || typeof ops !== 'object')
+        return lines;
+    const setOps = ops.set;
+    if (setOps && typeof setOps === 'object') {
+        for (const [key, value] of Object.entries(setOps)) {
+            const leaf = Object.keys(setOps).length === 1 ? leafFromSettingPath(settingPath, key) : key;
+            lines.push(`Set ${leaf} → ${formatScalar(value)}`);
+        }
+    }
+    const addOps = ops.add;
+    if (addOps && typeof addOps === 'object') {
+        for (const [key, items] of Object.entries(addOps)) {
+            if (!Array.isArray(items))
+                continue;
+            lines.push(`Add to ${key}: ${formatListDeltaItems(items)}`);
+        }
+    }
+    const removeOps = ops.remove;
+    if (removeOps && typeof removeOps === 'object') {
+        for (const [key, items] of Object.entries(removeOps)) {
+            if (Array.isArray(items)) {
+                lines.push(`Remove from ${key}: ${formatListDeltaItems(items)}`);
+                continue;
+            }
+            if (items && typeof items === 'object') {
+                lines.push(`Remove from ${key}: ${formatListDeltaItems(Object.keys(items))}`);
+            }
+        }
+    }
+    return lines;
+}
+function linesFromSqliteOp(check) {
+    const sqliteOp = check.sqlite_op;
+    if (!sqliteOp || typeof sqliteOp !== 'object')
+        return [];
+    const lines = [];
+    const settingPath = check.setting_path ?? '';
+    const updates = sqliteOp.updates;
+    if (updates && typeof updates === 'object') {
+        for (const [key, value] of Object.entries(updates)) {
+            lines.push(`Set ${leafFromSettingPath(settingPath, key)} → ${formatScalar(value)}`);
+        }
+    }
+    const unionAdd = sqliteOp.array_union_add;
+    if (Array.isArray(unionAdd) && unionAdd.length > 0) {
+        const target = sqliteOp.target_key ?? 'list';
+        lines.push(`Add to ${target}: ${formatListDeltaItems(unionAdd)}`);
+    }
+    return lines;
+}
+function linesFromCheck(check) {
+    const fromOps = linesFromOps(check);
+    if (fromOps.length > 0)
+        return fromOps;
+    return linesFromSqliteOp(check);
+}
+function linesFromFixSpec(spec) {
+    if (!spec)
+        return [];
+    if (Array.isArray(spec.checks) && spec.checks.length > 0) {
+        return spec.checks.flatMap((check) => linesFromCheck(check));
+    }
+    if (spec.setting_path || spec.ops) {
+        return linesFromCheck({ setting_path: spec.setting_path, ops: spec.ops });
+    }
+    return [];
+}
+/** Basename for macOS dialog copy (vscdb paths shortened). */
+export function previewFileLabel(configFilePath) {
+    if (!configFilePath?.trim())
+        return 'config file';
+    const normalized = configFilePath.replace(/\\/g, '/');
+    const hashIdx = normalized.indexOf('#');
+    const pathPart = hashIdx >= 0 ? normalized.slice(0, hashIdx) : normalized;
+    const fragment = hashIdx >= 0 ? normalized.slice(hashIdx + 1) : '';
+    const segments = pathPart.split('/').filter(Boolean);
+    const base = segments[segments.length - 1] ?? pathPart;
+    if (base.endsWith('.vscdb') || base === 'state.vscdb') {
+        if (fragment && fragment !== 'composerState') {
+            const short = fragment.length > 28
+                ? fragment.includes('/')
+                    ? (fragment.split('/').pop() ?? fragment)
+                    : fragment
+                : fragment;
+            return `state.vscdb (${short})`;
+        }
+        return 'state.vscdb';
+    }
+    return base || 'config file';
+}
+export function collectRemediationPreviewLines(appliedViolations, remediations, maxLines = MAX_PREVIEW_LINES) {
+    const byUuid = new Map(remediations.map((row) => [row.uuid, row]));
+    const fileLabels = new Set();
+    const allLines = [];
+    for (const violation of appliedViolations) {
+        const instruction = byUuid.get(violation.uuid);
+        const spec = instruction ? remediationFixSpec(instruction) : null;
+        fileLabels.add(previewFileLabel(instruction?.config_file_path ?? violation.config_file_path ?? ''));
+        allLines.push(...linesFromFixSpec(spec));
+    }
+    const lines = allLines.slice(0, maxLines);
+    const hiddenCount = Math.max(0, allLines.length - lines.length);
+    return { fileLabels: [...fileLabels], lines, hiddenCount };
+}
+export function formatRemediationChangePreviewSection(appliedViolations, remediations) {
+    const { fileLabels, lines, hiddenCount } = collectRemediationPreviewLines(appliedViolations, remediations);
+    if (lines.length === 0)
+        return '';
+    const filePart = fileLabels.length === 1
+        ? `Changes in ${fileLabels[0]}:`
+        : `Changes in ${fileLabels.slice(0, 2).join(', ')}${fileLabels.length > 2 ? ', …' : ''}:`;
+    const body = lines.map((line) => `  • ${truncateLine(line)}`).join('\n');
+    const tail = hiddenCount > 0
+        ? `\n  … and ${hiddenCount} more change${hiddenCount === 1 ? '' : 's'}`
+        : '';
+    return `${filePart}\n${body}${tail}`;
+}
+export function formatRemediationChangePreviewForApplied(appliedViolations) {
+    const { remediations } = readRemediationInstructionsFile();
+    return formatRemediationChangePreviewSection(appliedViolations, remediations);
+}

package/package.json

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