@optimuslabs/harness-map-staging 1.5.16 → 1.5.19

package/dist/log_config_files/collection/directory_collector.js

@@ -1,10 +1,20 @@
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { readJSONFile, readMarkdownFile } from '../readers/file_readers.js';
+import { collectSkillMdRecord, isSkillDirEntry } from './skill_symlink.js';
 function collectSubdirMdFiles(dirPath, fileType, mdFilename, source) {
     const results = [];
+    const isSkillMd = mdFilename.toLowerCase() === 'skill.md';
     try {
         for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+            if (isSkillMd) {
+                if (!isSkillDirEntry(entry))
+                    continue;
+                const record = collectSkillMdRecord(join(dirPath, entry.name), fileType, source, mdFilename);
+                if (record)
+                    results.push(record);
+                continue;
+            }
             if (!entry.isDirectory())
                 continue;
             const mdPath = join(dirPath, entry.name, mdFilename);

package/dist/log_config_files/collection/plugin_collector.js

@@ -5,6 +5,7 @@ import { createHash } from 'node:crypto';
 import { readJSONFile, readMarkdownFile } from '../readers/file_readers.js';
 import { getInstalledPluginsPath, getPluginHooksPath, getPluginMcpPaths, getPluginSkillFilename, getPluginSkillsDir } from '../paths/path_constants_helpers.js';
 import { versionFromPluginCachePath, parseInstalledPluginKey } from './plugin_version_helpers.js';
+import { collectSkillMdRecord, isSkillDirEntry, symlinkInfoAllowsExtraFiles } from './skill_symlink.js';
 /** Directories never worth shipping: git history is huge and already-compressed, deps are not the skill. */
 const SKILL_SKIP_DIRS = new Set(['.git', 'node_modules']);
 /** Fonts are the single largest thing in skill folders (canvas-design ships 54) and carry no signal. */
@@ -53,7 +54,9 @@ function collectSkillDirFiles(dir, results, constants, skillFilename, budget, de
                 collectSkillDirFiles(full, results, constants, skillFilename, budget, depth + 1);
             continue;
         }
-        // Symlinks report isSymbolicLink(), not isFile(), so this also keeps the walk inside the skill dir.
+        if (ent.name === skillFilename)
+            continue;
+        // Extra skill files: skip nested symlinks so the walk stays inside this skill dir.
         if (!ent.isFile())
             continue;
         const ext = extname(ent.name).toLowerCase();
@@ -100,11 +103,16 @@ function collectSkillDirFiles(dir, results, constants, skillFilename, budget, de
 function collectSkillFiles(skillsDir, results, constants) {
     const skillFilename = getPluginSkillFilename(constants);
     try {
-        for (const d of readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory())) {
+        for (const d of readdirSync(skillsDir, { withFileTypes: true }).filter((d) => isSkillDirEntry(d))) {
             const skillRoot = join(skillsDir, d.name);
-            if (!existsSync(join(skillRoot, skillFilename)))
+            const ver = versionFromPluginCachePath(join(skillRoot, skillFilename), constants);
+            const record = collectSkillMdRecord(skillRoot, 'claude_skill', 'file', skillFilename, ver ? { version: ver } : {});
+            if (!record)
+                continue;
+            results.push(record);
+            if (!symlinkInfoAllowsExtraFiles(record.symlink_info))
                 continue;
-            const budget = { files: 0, bytes: 0 };
+            const budget = { files: 1, bytes: 0 };
             collectSkillDirFiles(skillRoot, results, constants, skillFilename, budget, 0);
             if (budget.files >= SKILL_MAX_FILES || budget.bytes >= SKILL_MAX_TOTAL_BYTES) {
                 console.warn(`Skill ${skillRoot} hit collection cap (${budget.files} files, ${budget.bytes} bytes)`);

package/dist/log_config_files/collection/skill_symlink.js

@@ -0,0 +1,191 @@
+import { accessSync, constants, lstatSync, readlinkSync, realpathSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { readMarkdownFile } from '../readers/file_readers.js';
+function isMissingPathError(err) {
+    const code = err?.code;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+}
+/**
+ * Resolve readlink's raw target the way the OS does when parent dirs include
+ * symlinks. A lexical join against the logical parent is wrong when that parent
+ * is itself a link (e.g. ~/.config → a dotfiles repo).
+ */
+export function resolveRawSymlinkTarget(linkPath, target) {
+    if (isAbsolute(target))
+        return resolve(target);
+    const physicalParent = realpathSync(dirname(linkPath));
+    return resolve(physicalParent, target);
+}
+function probeAccess(path) {
+    try {
+        accessSync(path, constants.F_OK);
+        return 'valid';
+    }
+    catch (err) {
+        return isMissingPathError(err) ? 'broken' : 'inaccessible';
+    }
+}
+function readResolvedSymlinkTarget(linkPath) {
+    try {
+        const raw = readlinkSync(linkPath);
+        const target = resolveRawSymlinkTarget(linkPath, raw);
+        return { target, status: probeAccess(target) };
+    }
+    catch (err) {
+        if (err?.code === 'EINVAL') {
+            return { target: null, status: 'valid' };
+        }
+        return { target: null, status: isMissingPathError(err) ? 'broken' : 'inaccessible' };
+    }
+}
+function asOverall(status) {
+    return status === 'missing' ? 'broken' : status;
+}
+function worseStatus(current, next) {
+    const rank = { valid: 0, broken: 1, inaccessible: 2 };
+    return rank[next] > rank[current] ? next : current;
+}
+function emptyPath(path, status = 'valid') {
+    return { path, is_symlink: false, points_to: null, status };
+}
+/** True for a skills-dir child that is a real folder or a symlink slot. */
+export function isSkillDirEntry(entry) {
+    return entry.isDirectory() || Boolean(entry.isSymbolicLink?.());
+}
+/**
+ * Inspect one agent skill slot: the folder (local vs symlink) and SKILL.md inside it.
+ */
+export function inspectSkillLink(skillDir, skillFilename = 'SKILL.md') {
+    const skillMdPath = join(skillDir, skillFilename);
+    const skill_folder = emptyPath(skillDir);
+    const skill_md = emptyPath(skillMdPath);
+    try {
+        const dirStat = lstatSync(skillDir);
+        if (dirStat.isSymbolicLink()) {
+            skill_folder.is_symlink = true;
+            const resolved = readResolvedSymlinkTarget(skillDir);
+            skill_folder.points_to = resolved.target;
+            skill_folder.status = resolved.status;
+        }
+        else if (!dirStat.isDirectory()) {
+            skill_folder.status = 'broken';
+        }
+    }
+    catch (err) {
+        skill_folder.status = isMissingPathError(err) ? 'broken' : 'inaccessible';
+        skill_md.status = 'missing';
+        return {
+            status: asOverall(skill_folder.status),
+            skill_folder,
+            skill_md,
+        };
+    }
+    try {
+        const mdStat = lstatSync(skillMdPath);
+        if (mdStat.isSymbolicLink()) {
+            skill_md.is_symlink = true;
+            const resolved = readResolvedSymlinkTarget(skillMdPath);
+            skill_md.points_to = resolved.target;
+            skill_md.status = resolved.status;
+        }
+    }
+    catch (err) {
+        skill_md.status = isMissingPathError(err) ? 'missing' : 'inaccessible';
+    }
+    return {
+        status: worseStatus(asOverall(skill_folder.status), asOverall(skill_md.status)),
+        skill_folder,
+        skill_md,
+    };
+}
+function symlinkEntry(info) {
+    return {
+        path: info.path,
+        points_to: info.points_to,
+        status: info.status === 'missing' ? 'broken' : info.status,
+    };
+}
+/** Only include the path that is actually a symlink. No symlink → `{ symlink_enabled: false }`. */
+export function skillLinkPayload(info) {
+    const symlink_info = { symlink_enabled: false };
+    if (info.skill_folder.is_symlink) {
+        symlink_info.symlink_enabled = true;
+        symlink_info.skill_folder = symlinkEntry(info.skill_folder);
+    }
+    if (info.skill_md.is_symlink) {
+        symlink_info.symlink_enabled = true;
+        symlink_info.skill_md = symlinkEntry(info.skill_md);
+    }
+    return symlink_info;
+}
+export function symlinkInfoAllowsExtraFiles(info) {
+    if (!info || typeof info !== 'object')
+        return true;
+    const payload = info;
+    if (!payload.symlink_enabled)
+        return true;
+    for (const entry of [payload.skill_folder, payload.skill_md]) {
+        if (entry?.status && entry.status !== 'valid')
+            return false;
+    }
+    return true;
+}
+function shouldEmitSkillSlot(info, skillFilename) {
+    if (info.skill_folder.is_symlink)
+        return true;
+    if (info.status === 'inaccessible')
+        return true;
+    if (info.skill_md.is_symlink)
+        return true;
+    try {
+        accessSync(join(info.skill_folder.path, skillFilename), constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function unknownInspectFailure(skillDir, skillFilename, err) {
+    const status = isMissingPathError(err) ? 'broken' : 'inaccessible';
+    return {
+        status,
+        skill_folder: emptyPath(skillDir, status),
+        skill_md: emptyPath(join(skillDir, skillFilename), 'missing'),
+    };
+}
+/**
+ * Collect one SKILL.md inventory row, including symlink metadata even when the
+ * file is missing, dangling, or unreadable.
+ */
+export function collectSkillMdRecord(skillDir, fileType, source, skillFilename = 'SKILL.md', extraRaw = {}) {
+    let info;
+    try {
+        info = inspectSkillLink(skillDir, skillFilename);
+    }
+    catch (err) {
+        info = unknownInspectFailure(skillDir, skillFilename, err);
+    }
+    if (!shouldEmitSkillSlot(info, skillFilename))
+        return null;
+    const mdPath = join(skillDir, skillFilename);
+    const raw = {
+        source,
+        ...extraRaw,
+    };
+    const symlink_info = skillLinkPayload(info);
+    if (info.status === 'valid') {
+        const content = readMarkdownFile(mdPath);
+        if (content !== null) {
+            raw.content = content;
+        }
+        else if (symlink_info.symlink_enabled) {
+            const skill_md = symlink_info.skill_md;
+            const skill_folder = symlink_info.skill_folder;
+            if (skill_md)
+                skill_md.status = 'inaccessible';
+            else if (skill_folder)
+                skill_folder.status = 'inaccessible';
+        }
+    }
+    return { file_type: fileType, file_path: mdPath, raw_content: raw, symlink_info };
+}

package/dist/log_config_files/runtime/compliance_check.js

@@ -89,6 +89,12 @@ function targetsCurrentAgent(entry, agent) {
         complianceRunnerDiag(`Ignoring remediation with unknown target_agent: ${t}`);
         return false;
     }
+    // Claude Desktop cannot run hooks, so nothing ever executes with --agent=claude_desktop and
+    // these rows would otherwise never be applied by anyone. The Claude Code hook owns them: it
+    // writes Desktop's own config file and the spec's restart_command relaunches the app
+    // (trusted_restarts already maps claude_desktop -> claude for exactly this reason).
+    if (normalized === 'claude_desktop' && agent === 'claude')
+        return true;
     return normalized === agent;
 }
 // ---------------------------------------------------------------------------
@@ -361,6 +367,28 @@ function violationFromCheck(entry, compliance, check, 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}`,
     };
 }
+/**
+ * True when a secret-scan hit sits at (or under) a path this remediation has ops for.
+ *
+ * The scan reads the whole file, but the entry only carries ops for its own checks. Blocking on
+ * any other hit pins the row non-compliant forever -- the gate re-prompts on every turn with a fix
+ * that cannot resolve it (e.g. Claude Code's own 64-hex `machineID` matching a provider pattern).
+ */
+function secretFindingIsOwnedByEntry(findingPath, entry, checks) {
+    return checks.some((check) => {
+        const target = canonicalComplianceSettingPath(entry.config_file_path, check);
+        if (!target)
+            return false;
+        if (target.includes('*')) {
+            const pattern = target
+                .split('.')
+                .map((seg) => (seg === '*' ? '[^.]+' : seg.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')))
+                .join('\\.');
+            return new RegExp(`^${pattern}(\\.|$)`).test(findingPath);
+        }
+        return findingPath === target || findingPath.startsWith(`${target}.`);
+    });
+}
 /** Evaluate one manifest row against on-disk config (used by gate + post-restart verify). */
 export function evaluateManifestEntryCompliance(entry) {
     const compliance = entry.fix ?? entry.compliance;
@@ -370,11 +398,15 @@ export function evaluateManifestEntryCompliance(entry) {
     if (checks.length === 0)
         return { violations: [] };
     const loaded = loadRemediationConfigJson(entry.config_file_path, checks.map((c) => c.setting_path));
-    if (!loaded.ok)
-        return { violations: [] };
+    if (!loaded.ok) {
+        // A config we cannot read is not a config we can call compliant. file_not_found is genuinely
+        // compliant (the config is gone); any other reason means the file is there and we simply could
+        // not parse it, so callers must not treat the empty violation list as "verified".
+        return { violations: [], unevaluable: loaded.reason !== 'file_not_found' };
+    }
     const configJson = loaded.json;
     if (compliance.requires_secret_scan === true) {
-        const secretFindings = scanJsonForHardcodedSecrets(configJson);
+        const secretFindings = scanJsonForHardcodedSecrets(configJson).filter((f) => secretFindingIsOwnedByEntry(f.path, entry, checks));
         return secretFindings.length === 0
             ? { violations: [] }
             : {
@@ -565,8 +597,12 @@ export function reportPostRestartVerificationOutcomes(violations) {
     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;
+        if (entry) {
+            // Unreadable config counts as still-violating: never verify what could not be checked.
+            const { violations: entryViolations, unevaluable } = evaluateManifestEntryCompliance(entry);
+            if (unevaluable || entryViolations.length > 0)
+                return true;
+        }
         return violations.some((v) => v.uuid === uuid);
     });
     const reportPromises = outcomes.map((o) => {
@@ -597,6 +633,35 @@ export async function runPostApplyVerification(agent = 'cursor') {
     }
     return outcomes;
 }
+/**
+ * Re-read the remediated config so the server can verify the apply instead of trusting the report.
+ *
+ * Without a snapshot the server's post-apply re-check has nothing to evaluate and clears the
+ * linked findings on the endpoint's word alone -- the same blind close that let a fix that never
+ * happened be recorded as remediated. vscdb-backed paths are not JSON files, so they stay absent.
+ */
+function configSnapshotForReport(configFilePath) {
+    const diskPath = resolveRemediationConfigPath(configFilePath);
+    if (diskPath.includes('#'))
+        return undefined;
+    try {
+        const parsed = parseJsonWithJsoncFallback(readFileSync(diskPath, 'utf8'));
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        /* unreadable: report without a snapshot rather than failing the report */
+    }
+    return undefined;
+}
+/** Report an apply outcome, attaching the on-disk config only when it can actually be read. */
+function reportAutofixWithSnapshot(uuid, result, configFilePath) {
+    const snapshot = configSnapshotForReport(configFilePath);
+    return snapshot
+        ? reportAutofixApplied(uuid, result, { config_snapshot_after: snapshot })
+        : reportAutofixApplied(uuid, result);
+}
 /**
  * Immediate autofix succeeded (inline recheck OK or Claude stale-recheck tolerance).
  * Clear pending verification locally and report verified so the next prompt does not POST
@@ -605,7 +670,7 @@ export async function runPostApplyVerification(agent = 'cursor') {
 export function confirmAppliedAutofixVerified(appliedViolations, reportPromises) {
     for (const v of appliedViolations) {
         markRemediationApplyVerified(v.uuid);
-        reportPromises.push(reportAutofixApplied(v.uuid, 'verified'));
+        reportPromises.push(reportAutofixWithSnapshot(v.uuid, 'verified', v.config_file_path));
     }
 }
 export function applyAutofixViolations(violations, agent = 'cursor') {
@@ -682,7 +747,7 @@ export function applyAutofixViolations(violations, agent = 'cursor') {
         fixed++;
         appliedViolations.push(violation);
         hookRunLog(`autofix: applied uuid=${inst.uuid} path=${configPathForDisk}`);
-        reportPromises.push(reportAutofixApplied(inst.uuid, 'success'));
+        reportPromises.push(reportAutofixWithSnapshot(inst.uuid, 'success', inst.config_file_path));
         // 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);
@@ -904,8 +969,8 @@ export function uploadSatisfiedManifestConfigs(agent = 'cursor') {
     const entries = remediations.filter((e) => targetsCurrentAgent(e, agent));
     const promises = [];
     for (const entry of entries) {
-        const { violations } = evaluateManifestEntryCompliance(entry);
-        if (violations.length > 0)
+        const { violations, unevaluable } = evaluateManifestEntryCompliance(entry);
+        if (violations.length > 0 || unevaluable)
             continue;
         const inst = entry;
         const uploadFileType = resolveRemediationUploadFileType(entry.config_file_path, inst.file_type ?? undefined);
@@ -969,8 +1034,8 @@ export function reportCompliantRemediationVerifiedStatus(agent = 'cursor') {
     const entries = remediations.filter((e) => targetsCurrentAgent(e, agent));
     const promises = [];
     for (const entry of entries) {
-        const { violations } = evaluateManifestEntryCompliance(entry);
-        if (violations.length > 0)
+        const { violations, unevaluable } = evaluateManifestEntryCompliance(entry);
+        if (violations.length > 0 || unevaluable)
             continue;
         const tracking = readRemediationApplyTrackingFile();
         const prev = tracking.entries[entry.uuid];
@@ -982,7 +1047,13 @@ export function reportCompliantRemediationVerifiedStatus(agent = 'cursor') {
         const rawContent = parseJsonWithJsoncFallback(readFileSync(diskPath, 'utf8'));
         if (rawContent === null)
             continue;
-        promises.push(reportAutofixApplied(entry.uuid, 'verified', { config_snapshot_after: rawContent }).then(() => {
+        promises.push(
+        // Nothing was applied on this path, so before === after. Sending both makes a no-op
+        // "verified" distinguishable from a real apply in EnforcementLog.
+        reportAutofixApplied(entry.uuid, 'verified', {
+            config_snapshot_before: rawContent,
+            config_snapshot_after: rawContent,
+        }).then(() => {
             markRemediationApplyVerified(entry.uuid);
             hookRunLog(`compliance_check: reported verified (already compliant) uuid=${entry.uuid}`);
         }));

package/dist/log_config_files/runtime/prompt-collection-policy.js

@@ -0,0 +1,57 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/** Org-pushed endpoint config. Prompt collection and later org options share this file. */
+const ORG_CONFIG_RELATIVE_PATH = path.join(".optimuslabs", "management", "org", "config.json");
+export function orgConfigPath() {
+    return path.join(os.homedir(), ORG_CONFIG_RELATIVE_PATH);
+}
+function readOrgConfig() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(orgConfigPath(), "utf8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Missing or invalid — treat as empty.
+    }
+    return {};
+}
+function collectPromptsFromConfig(cfg) {
+    if (typeof cfg.collect_prompts === "boolean")
+        return cfg.collect_prompts;
+    // Previous on-disk key was inverted (true = hash / don't collect).
+    if (typeof cfg.hash_tool_call_prompts === "boolean")
+        return cfg.hash_tool_call_prompts !== true;
+    // No org config yet: match server default (collection off).
+    return false;
+}
+export function readCollectPrompts() {
+    return collectPromptsFromConfig(readOrgConfig());
+}
+export function persistCollectPrompts(value) {
+    if (typeof value !== "boolean")
+        return;
+    const filePath = orgConfigPath();
+    try {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        const next = { ...readOrgConfig(), collect_prompts: value };
+        delete next.hash_tool_call_prompts;
+        fs.writeFileSync(filePath, `${JSON.stringify(next)}\n`, { encoding: "utf8", mode: 0o600 });
+    }
+    catch {
+        // Best-effort: next heartbeat can retry.
+    }
+}
+export function persistCollectPromptsFromResponse(body) {
+    if (!body || typeof body !== "object")
+        return;
+    if (typeof body.collect_prompts === "boolean") {
+        persistCollectPrompts(body.collect_prompts);
+        return;
+    }
+    if (typeof body.hash_tool_call_prompts === "boolean") {
+        persistCollectPrompts(body.hash_tool_call_prompts !== true);
+    }
+}

package/dist/log_config_files/runtime/remediation_sync.js

@@ -551,15 +551,26 @@ function assertSafeSqliteIdentifiersForItemTable(table, keyColumn, valueColumn)
 const TRUSTED_CURSOR_SQLITE_DEFERRED_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 && ' +
     'OPTIMUS_DEFERRED_LOG="${HOME}/.optimuslabs/management/vscdb/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/.optimuslabs/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/optimuslabs/log-llm-config/dist/apply_deferred_vscdb.js\" ]; then echo deferred_restart:apply_via_optimus_npx_base; node \"\$NPX_BASE/optimuslabs/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=@optimuslabs/harness-map-staging@latest apply-deferred-vscdb-staging; APPLY_EC=\$?; else npx --yes --package=@optimuslabs/harness-map@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";
+    "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/.optimuslabs/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/optimuslabs/harness-map/dist/apply_deferred_vscdb.js\" ]; then echo deferred_restart:apply_via_optimus_npx_base; node \"\$NPX_BASE/optimuslabs/harness-map/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=@optimuslabs/harness-map-staging@latest apply-deferred-vscdb-staging; APPLY_EC=\$?; else npx --yes --package=@optimuslabs/harness-map@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";
 /** 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'";
+/** Pre-wait-loop command; still accepted so an older manifest keeps restarting on a new client. */
+const TRUSTED_CLAUDE_RESTART_COMMAND_LEGACY = "nohup bash -c 'sleep 2 && open -a Claude' >/dev/null 2>&1 & pkill -x 'Claude'";
+/**
+ * Relaunch Claude Desktop once it has actually exited.
+ *
+ * The legacy command killed the app and relaunched after a flat 2s. A quit that takes longer (state
+ * save) meant `open -a Claude` landed while the app was still terminating, the launch was coalesced
+ * into the dying instance, and Desktop never came back. Poll for exit instead, bounded at ~20s.
+ * executeTrustedRestartCommands already spawns this detached, so it runs inline (no nohup/&).
+ */
+const TRUSTED_CLAUDE_RESTART_COMMAND = "pkill -x 'Claude'; for i in $(seq 1 80); do pgrep -x 'Claude' >/dev/null || break; sleep 0.25; done; open -a Claude";
 export function isClaudeRestartCommand(cmd) {
-    return cmd.trim() === TRUSTED_CLAUDE_RESTART_COMMAND;
+    const t = cmd.trim();
+    return t === TRUSTED_CLAUDE_RESTART_COMMAND || t === TRUSTED_CLAUDE_RESTART_COMMAND_LEGACY;
 }
 export function isCursorRestartCommand(cmd) {
     const t = cmd.trim();
@@ -579,7 +590,8 @@ export function isTrustedRestartCommandForAutofix(cmd) {
     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);
+        t === TRUSTED_CLAUDE_RESTART_COMMAND ||
+        t === TRUSTED_CLAUDE_RESTART_COMMAND_LEGACY);
 }
 /** Legacy Cursor: dedicated ItemTable row `composerState`. Current Cursor: nested under reactive `applicationUser` blob. */
 function cursorVscdbHasUsableComposerStateRow(dbPath, sqliteOp) {
@@ -1537,6 +1549,9 @@ export function reportAutofixApplied(remediationUuid, result, details) {
     if (details?.config_snapshot_after && typeof details.config_snapshot_after === 'object') {
         bodyPayload.config_snapshot_after = details.config_snapshot_after;
     }
+    if (details?.config_snapshot_before && typeof details.config_snapshot_before === 'object') {
+        bodyPayload.config_snapshot_before = details.config_snapshot_before;
+    }
     const signature = createSignature(payload, authKey.key);
     const body = JSON.stringify({ ...bodyPayload, signature });
     return executeBody(url, 'POST', body, 8000)

package/dist/log_config_files/runtime/secret_regex_scan.js

@@ -38,10 +38,12 @@ const KNOWN_SECRET_PATTERNS = [
     { re: /ASIA[0-9A-Z]{16}/i, label: 'AWS temporary access key ID' },
     { re: /AIza[0-9A-Za-z_-]{35}/i, label: 'Google API key' },
     { re: /ya29\.[0-9A-Za-z_-]+/i, label: 'Google OAuth access token' },
-    { re: /AC[a-z0-9]{32}/i, label: 'Twilio account SID' },
-    { re: /SK[a-z0-9]{32}/i, label: 'Twilio API key' },
+    // Anchored + case-sensitive: Twilio SIDs are uppercase AC/SK + exactly 32 hex. Unanchored
+    // /AC[a-z0-9]{32}/i matched any long hex string containing "ac" (e.g. a 64-hex machine id).
+    { re: /\bAC[a-f0-9]{32}\b/, label: 'Twilio account SID' },
+    { re: /\bSK[a-f0-9]{32}\b/, label: 'Twilio API key' },
     { re: /SG\.[a-zA-Z0-9_-]{22}\.[a-zA-Z0-9_-]{43}/i, label: 'SendGrid API key' },
-    { re: /key-[a-f0-9]{32}/i, label: 'Mailgun API key' },
+    { re: /\bkey-[a-f0-9]{32}\b/i, label: 'Mailgun API key' },
     { re: /npm_[a-zA-Z0-9]{36}/i, label: 'npm access token' },
     { re: /pypi-[a-zA-Z0-9_-]{50,}/i, label: 'PyPI API token' },
     { re: /discord(?:app)?\.com\/api\/webhooks\/\d+\/[a-zA-Z0-9_-]+/i, label: 'Discord webhook URL' },
@@ -57,7 +59,9 @@ const KNOWN_SECRET_PATTERNS = [
     { re: /Bearer\s+[a-zA-Z0-9\-_.]{20,}/i, label: 'Bearer token' },
 ];
 const BASIC_AUTH_IN_URL = /[a-zA-Z0-9._%+-]+:[a-zA-Z0-9._%+-]+@/gi;
-const GENERIC_TOKEN = /\b[a-zA-Z0-9]{32,}\b/g;
+// Hyphens/underscores count as part of one token so hyphenated keys (ctx7sk-..., sk-ant-...)
+// are measured as a single candidate instead of segment-by-segment (matches HardcodedSecretRule).
+const GENERIC_TOKEN = /\b[a-zA-Z0-9][a-zA-Z0-9_-]{31,}\b/g;
 const GENERIC_KEY_HINT = /(?:api[_-]?key|app[_-]?key|secret|token|password|passwd|pass\b|(?<!o)auth|credential|private[_-]?key|access[_-]?key|master[_-]?key)/i;
 function basicAuthMatchIsCredential(value, matchIndex) {
     const before = value.slice(0, matchIndex);
@@ -70,6 +74,20 @@ function basicAuthMatchIsCredential(value, matchIndex) {
 function looksLikeUrlContext(value) {
     return value.includes(':') && (value.toLowerCase().includes('http') || value.includes('://'));
 }
+/**
+ * Values to run GENERIC_TOKEN against. A URL's host/path is skipped (high false-positive rate),
+ * but query-string values are scanned — MCP tokens commonly live there. Mirrors
+ * HardcodedSecretRule._generic_token_scan_targets.
+ */
+function genericTokenScanTargets(value) {
+    if (!looksLikeUrlContext(value))
+        return [value];
+    const queryStart = value.indexOf('?');
+    if (queryStart === -1)
+        return [];
+    const query = value.slice(queryStart + 1).split('#')[0] ?? '';
+    return [...new URLSearchParams(query).values()];
+}
 /**
  * Scan one scalar config value. Returns secret type label or null if clean / env-backed.
  */
@@ -89,12 +107,14 @@ export function scanScalarForHardcodedSecret(value, keyName) {
             return 'Basic authentication credentials';
         }
     }
-    if (!GENERIC_KEY_HINT.test(keyName) || looksLikeUrlContext(valueStr)) {
+    if (!GENERIC_KEY_HINT.test(keyName)) {
         return null;
     }
-    const genericMatches = valueStr.match(GENERIC_TOKEN) ?? [];
-    if (genericMatches.some((token) => token.length >= 40)) {
-        return 'Potential token/secret';
+    for (const target of genericTokenScanTargets(valueStr)) {
+        const genericMatches = target.match(GENERIC_TOKEN) ?? [];
+        if (genericMatches.some((token) => token.length >= 40)) {
+            return 'Potential token/secret';
+        }
     }
     return null;
 }

package/dist/log_config_files/sender/batch_sender.js

@@ -4,6 +4,7 @@ import { loadEndpointBase } from './endpoint_config.js';
 import { hookRunLog } from '../runtime/hook_logger.js';
 import { canonicalCursorUserStateVscdbPath } from '../runtime/remediation_config_path.js';
 import { resolveWorkspaceRepoFromEnv } from '../runtime/workspace_repo.js';
+import { persistCollectPromptsFromResponse } from '../runtime/prompt-collection-policy.js';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -79,11 +80,16 @@ function buildBatchChunks(configFiles, basePayloadSize) {
     return chunks;
 }
 function buildChunkBody(chunk, hardwareUuid, authKey, hookRequestId, metadata) {
-    const config_files = chunk.map((c) => ({
-        file_type: c.file_type,
-        file_path: canonicalCursorUserStateVscdbPath(c.file_path),
-        raw_content: c.raw_content,
-    }));
+    const config_files = chunk.map((c) => {
+        const item = {
+            file_type: c.file_type,
+            file_path: canonicalCursorUserStateVscdbPath(c.file_path),
+            raw_content: c.raw_content,
+        };
+        if (c.symlink_info !== undefined)
+            item.symlink_info = c.symlink_info;
+        return item;
+    });
     const payload = { hardware_uuid: hardwareUuid, metadata, config_files };
     if (hookRequestId != null)
         payload.hook_request_id = hookRequestId;
@@ -127,6 +133,7 @@ async function sendConfigFilesBatch(configFiles, hardwareUuid, authKey, hookRequ
         const timeoutMs = Math.min(20000 + Math.ceil(bodySize / (1024 * 1024)) * 15000, 90000);
         try {
             const response = (await postStartupPayload(apiUrl, body, timeoutMs));
+            persistCollectPromptsFromResponse(response);
             if (response.status === 'accepted') {
                 totals.accepted += typeof response.accepted === 'number' ? response.accepted : chunk.length;
                 const failedList = Array.isArray(response.failed) ? response.failed : [];
@@ -221,6 +228,8 @@ async function sendConfigFile(configFile, hardwareUuid, authKey, repoIdentifier)
     const apiUrl = `${resolveApiBase(endpoint)}/endpoint_security/log-config-file/`;
     const uploadPath = canonicalCursorUserStateVscdbPath(configFile.file_path);
     const payload = { hardware_uuid: hardwareUuid, file_type: configFile.file_type, file_path: uploadPath, raw_content: configFile.raw_content };
+    if (configFile.symlink_info !== undefined)
+        payload.symlink_info = configFile.symlink_info;
     const signature = createSignature(payload, authKey.key);
     const body = { ...payload, signature, key_id: authKey.key_id || '', metadata: { org_identifier: process.env.GITHUB_ORG || process.env.GH_ORG || '', organization_uuid: readOrganizationUuid(), repo_identifier: repoIdentifier ?? resolveWorkspaceRepoFromEnv() } };
     try {

package/dist/log_uuid/startup_sender.js

@@ -5,6 +5,7 @@ import { resolveHardwareUuid } from './hardware_uuid.js';
 import { writeAuthKey, readStoredAuthKey, loadEndpointBase, buildStartupEndpointUrl } from './auth_key_store.js';
 import { resolveUserProfile } from './user_profile.js';
 import { resolveWorkspaceRepo } from '../log_config_files/runtime/workspace_repo.js';
+import { persistCollectPromptsFromResponse } from '../log_config_files/runtime/prompt-collection-policy.js';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -83,6 +84,7 @@ const maybeSendToEndpoint = async (hardwareUuid, timestamp, options = {}) => {
     const requestBody = buildRequestBody(hardwareUuid, timestamp);
     try {
         const response = await postStartupPayload(startupEndpointUrl, requestBody);
+        persistCollectPromptsFromResponse(response);
         const result = classifyEndpointResponse(response);
         console.log(result.message);
         if (result.branch === 'key_issued' && result.key) {

package/dist/tofu.js

@@ -4,7 +4,7 @@
  * Reads ~/.optimuslabs/management/optimus_dev.env at startup:
  *   - No file / unreadable → staging (ignores OPTIMUS_ENVIRONMENT).
  *   - File present → environment= line in file, then OPTIMUS_ENVIRONMENT, then staging.
- *   - environment=development + local dist present → loads sibling optimus-tofu dist
+ *   - environment=development + local dist present → loads sibling tofu dist
  *   - staging / production / npx installs → published @optimuslabs/tofu-staging npm package
  *
  * All other source files import from this module, never directly from
@@ -14,7 +14,7 @@ import path from "path";
 import { fileURLToPath } from "url";
 import { shouldUseLocalTofuDist } from "./tofu_environment.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const localTofuPath = path.join(__dirname, "../../optimus-tofu/dist/index.js");
+const localTofuPath = path.join(__dirname, "../../tofu/dist/index.js");
 const useLocalTofu = shouldUseLocalTofuDist(localTofuPath);
 const tofu = (useLocalTofu
     ? await import(localTofuPath)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optimuslabs/harness-map-staging",
-  "version": "1.5.16",
+  "version": "1.5.19",
   "description": "CLI helpers for logging hardware UUIDs and posting startup payloads to Optimus Security.",
   "type": "module",
   "bin": {
@@ -34,12 +34,12 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/optimuslabs-io/optimus-secure-fdn.git",
-    "directory": "npx_packages/staging/optimuslabs/log-llm-config"
+    "directory": "npx_packages/staging/optimuslabs/harness-map"
   },
   "bugs": {
     "url": "https://github.com/optimuslabs-io/optimus-secure-fdn/issues"
   },
-  "homepage": "https://github.com/optimuslabs-io/optimus-secure-fdn/tree/main/npx_packages/staging/optimuslabs/log-llm-config#readme",
+  "homepage": "https://github.com/optimuslabs-io/optimus-secure-fdn/tree/main/npx_packages/staging/optimuslabs/harness-map#readme",
   "files": [
     "dist/**/*",
     "README.md"