nexus-agents 2.81.4 → 2.83.0

package/dist/{chunk-R2VJY7Z4.js → chunk-4BXQ2OZY.js}

@@ -1,24 +1,24 @@
-import {
-  CUSTOM_API_BASE_URL_ENV,
-  PROVIDER_ENV_KEYS,
-  validateCustomApiBaseUrl
-} from "./chunk-AMFVUDWI.js";
 import {
   AdapterModelError,
   BaseAdapter,
   createStream,
   requireApiKey,
   validateApiKeyPresence
-} from "./chunk-M5ABED6T.js";
+} from "./chunk-54UXPJVM.js";
+import {
+  CUSTOM_API_BASE_URL_ENV,
+  PROVIDER_ENV_KEYS,
+  validateCustomApiBaseUrl
+} from "./chunk-ZIWEEVMI.js";
 import {
   getToolMemory
-} from "./chunk-JSQV2EOZ.js";
+} from "./chunk-YO27YAEX.js";
 import {
   getDefaultAvailableModelsCache
-} from "./chunk-7JLSKX3U.js";
+} from "./chunk-Q6PZMGLU.js";
 import {
   CUSTOM_API_DEFAULT_MODEL
-} from "./chunk-2HBQ6XXA.js";
+} from "./chunk-ZM5JKJHI.js";
 import {
   createCliAdapter,
   createCliDetectionCache,
@@ -27,7 +27,7 @@ import {
   isCliAvailable,
   sanitizeOutput,
   withTimeout
-} from "./chunk-WVSQGGAH.js";
+} from "./chunk-FHGDJKCZ.js";
 import {
   AgentError,
   CACHE_TIMEOUTS,
@@ -70,7 +70,7 @@ import {
   resolveCliAlias,
   resolveVoteTimeout,
   toRateLimitError
-} from "./chunk-HFSSADUV.js";
+} from "./chunk-RXVH52UI.js";
 import {
   ensureLearningDir,
   getNexusDataDir,
@@ -1345,11 +1345,15 @@ function toSdkCallback(handler) {
 }
 var MCP_SDK_DEFAULT_REQUEST_TIMEOUT_MS = 6e4;
 var TIMEOUT_MISMATCH_TELEMETRY_REL_PATH = "mcp-telemetry/timeout-mismatch-events.jsonl";
+var ensuredDirs = /* @__PURE__ */ new Set();
 function appendTimeoutMismatchEvent(event) {
   try {
     const path = join(getNexusDataDir(), TIMEOUT_MISMATCH_TELEMETRY_REL_PATH);
     const dir = dirname(path);
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    if (!ensuredDirs.has(dir)) {
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+      ensuredDirs.add(dir);
+    }
     appendFileSync(path, JSON.stringify(event) + "\n", "utf-8");
   } catch (err2) {
     wrapperLogger.debug("Best-effort timeout-mismatch event recording failed", {
@@ -1792,7 +1796,7 @@ async function executeAndAudit(handler, sanitizedArgs, requestContext, requestLo
     }
     return result;
   } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
+    const rawMessage = error instanceof Error ? error.message : "Unknown error";
     requestLogger.error("Tool execution failed", error instanceof Error ? error : void 0);
     if (config.auditLogger) {
       emitToolAuditException(
@@ -1802,7 +1806,8 @@ async function executeAndAudit(handler, sanitizedArgs, requestContext, requestLo
         getTimeProvider().now() - execStartTime
       );
     }
-    return internalError(message, requestContext.requestId);
+    const sanitized = sanitizeOutput2(rawMessage, requestLogger);
+    return internalError(sanitized, requestContext.requestId);
   }
 }
 
@@ -3634,12 +3639,24 @@ async function pickFallback(retiredModelId, cache, registry) {
 }
 function wrapResilientWithFallback(inner, options = {}) {
   const wrapped = withModelNotFoundFallback(inner, options);
-  return Object.assign(wrapped, {
+  const surface = {
     getHealth: inner.getHealth.bind(inner),
     refresh: inner.refresh.bind(inner),
     setPreferredCli: inner.setPreferredCli.bind(inner),
     onFailover: inner.onFailover.bind(inner),
     dispose: inner.dispose.bind(inner)
+  };
+  const explicit = Object.assign(wrapped, surface);
+  const innerAsRecord = inner;
+  return new Proxy(explicit, {
+    get(target, prop, receiver) {
+      if (prop in target) return Reflect.get(target, prop, receiver);
+      const innerProp = innerAsRecord[prop];
+      if (typeof innerProp === "function") {
+        return innerProp.bind(inner);
+      }
+      return innerProp;
+    }
   });
 }
 
@@ -7639,9 +7656,10 @@ import { z as z8 } from "zod";
 var logger6 = createLogger({ component: "correlation-persistence" });
 var VOTING_SUBDIR = "voting";
 var CORRELATIONS_FILE = "correlations.json";
+var CORRELATIONS_JSONL_FILE = "correlations.jsonl";
 var FILE_MODE = 384;
 var DIR_MODE = 448;
-var SCHEMA_VERSION = 1;
+var SCHEMA_VERSION = 2;
 var PersistedVoteSchema = z8.object({
   agentId: z8.string(),
   decision: z8.enum(["approve", "reject", "abstain"]),
@@ -7661,6 +7679,9 @@ var PersistedCorrelationDataSchema = z8.object({
 function getCorrelationDataPath() {
   return nexusDataPath(VOTING_SUBDIR, CORRELATIONS_FILE);
 }
+function getCorrelationJsonlPath() {
+  return nexusDataPath(VOTING_SUBDIR, CORRELATIONS_JSONL_FILE);
+}
 function ensureVotingDirectory() {
   const dirPath = nexusDataPath(VOTING_SUBDIR);
   try {
@@ -7671,116 +7692,137 @@ function ensureVotingDirectory() {
     return err(new Error(`Failed to create voting directory at ${dirPath}: ${error.message}`));
   }
 }
-function mergeProposals(existingProposals, newProposals, maxProposals) {
-  const proposalMap = /* @__PURE__ */ new Map();
-  for (const proposal of existingProposals) {
-    proposalMap.set(proposal.proposalId, proposal);
-  }
-  for (const proposal of newProposals) {
-    proposalMap.set(proposal.proposalId, proposal);
-  }
-  const merged = Array.from(proposalMap.values());
-  merged.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-  if (merged.length > maxProposals) {
-    return merged.slice(merged.length - maxProposals);
-  }
-  return merged;
-}
-function saveCorrelationData(proposals, config = DEFAULT_HIGHER_ORDER_CONFIG) {
+function saveCorrelationData(proposals, _config = DEFAULT_HIGHER_ORDER_CONFIG) {
   const dirResult = ensureVotingDirectory();
   if (!dirResult.ok) return dirResult;
-  const filePath = getCorrelationDataPath();
-  let existingProposals = [];
-  const loadResult = loadCorrelationData();
-  if (loadResult.ok) {
-    existingProposals = loadResult.value.proposals;
-  }
-  const merged = mergeProposals(existingProposals, proposals, config.maxProposals);
-  const data = {
-    version: SCHEMA_VERSION,
-    proposals: merged,
-    savedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const json = JSON.stringify(data, null, 2);
-  const tempPath = `${filePath}.tmp.${String(process.pid)}`;
+  if (proposals.length === 0) return ok(void 0);
+  const filePath = getCorrelationJsonlPath();
   try {
-    fs.writeFileSync(tempPath, json, { encoding: "utf-8", mode: FILE_MODE });
-    fs.renameSync(tempPath, filePath);
-    logger6.info("Correlation data saved", {
+    const lines = proposals.map((p) => JSON.stringify(p)).join("\n") + "\n";
+    fs.appendFileSync(filePath, lines, { encoding: "utf-8", mode: FILE_MODE });
+    logger6.info("Correlation proposals appended", {
       path: filePath,
-      proposalCount: merged.length
+      proposalCount: proposals.length
     });
     return ok(void 0);
   } catch (cause) {
-    try {
-      fs.unlinkSync(tempPath);
-    } catch (cleanupErr) {
-      const msg = cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr);
-      logger6.debug("Failed to clean up temp file during correlation save", {
-        path: tempPath,
-        error: msg
-      });
-    }
     const error = cause instanceof Error ? cause : new Error(String(cause));
-    return err(new Error(`Failed to save correlation data: ${error.message}`));
+    return err(new Error(`Failed to append correlation data: ${error.message}`));
   }
 }
-function readAndParseFile(filePath) {
-  if (!fs.existsSync(filePath)) {
-    return err(new Error(`Correlation data file not found: ${filePath}`));
-  }
+function loadLegacyJsonProposals() {
+  const filePath = getCorrelationDataPath();
+  if (!fs.existsSync(filePath)) return [];
   let rawContent;
   try {
     rawContent = fs.readFileSync(filePath, { encoding: "utf-8" });
   } catch (cause) {
-    const error = cause instanceof Error ? cause : new Error(String(cause));
-    return err(new Error(`Failed to read correlation data: ${error.message}`));
+    logger6.warn("Failed to read legacy correlations.json", {
+      path: filePath,
+      error: cause instanceof Error ? cause.message : String(cause)
+    });
+    return [];
   }
+  let parsed;
   try {
-    return ok(JSON.parse(rawContent));
+    parsed = JSON.parse(rawContent);
   } catch (cause) {
-    const error = cause instanceof Error ? cause : new Error(String(cause));
-    logger6.warn("Corrupt correlation data file, will start fresh", {
+    logger6.warn("Corrupt legacy correlations.json \u2014 skipping", {
+      path: filePath,
+      error: cause instanceof Error ? cause.message : String(cause)
+    });
+    return [];
+  }
+  const result = PersistedCorrelationDataSchema.safeParse(parsed);
+  if (!result.success) {
+    logger6.warn("Invalid legacy correlations.json schema \u2014 skipping", {
       path: filePath,
-      error: error.message
+      error: result.error.message
     });
-    return err(new Error(`Corrupt correlation data (invalid JSON): ${error.message}`));
+    return [];
   }
+  return result.data.proposals;
 }
-function validateCorrelationData(parsed, filePath) {
-  const validation = PersistedCorrelationDataSchema.safeParse(parsed);
-  if (!validation.success) {
-    logger6.warn("Invalid correlation data schema, will start fresh", {
+function parseJsonlLine(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch (cause) {
+    return {
+      kind: "skip",
+      reason: `JSON.parse: ${cause instanceof Error ? cause.message : String(cause)}`
+    };
+  }
+  const result = PersistedProposalSchema.safeParse(parsed);
+  if (!result.success) return { kind: "skip", reason: `schema: ${result.error.message}` };
+  return { kind: "ok", proposal: result.data };
+}
+function loadJsonlProposals() {
+  const filePath = getCorrelationJsonlPath();
+  if (!fs.existsSync(filePath)) return [];
+  let content;
+  try {
+    content = fs.readFileSync(filePath, { encoding: "utf-8" });
+  } catch (cause) {
+    logger6.warn("Failed to read correlations.jsonl", {
       path: filePath,
-      errors: validation.error.issues.map((issue) => issue.message)
+      error: cause instanceof Error ? cause.message : String(cause)
     });
-    return err(new Error(`Invalid correlation data schema: ${validation.error.message}`));
+    return [];
+  }
+  const lines = content.split("\n").filter((line) => line.trim() !== "");
+  const proposals = [];
+  let skippedCount = 0;
+  let firstSkipReason;
+  for (const line of lines) {
+    const result = parseJsonlLine(line);
+    if (result.kind === "ok") {
+      proposals.push(result.proposal);
+    } else {
+      skippedCount++;
+      firstSkipReason ??= result.reason;
+    }
   }
-  if (validation.data.version > SCHEMA_VERSION) {
-    logger6.warn("Correlation data from newer version, will start fresh", {
-      fileVersion: validation.data.version,
-      currentVersion: SCHEMA_VERSION
+  if (skippedCount > 0) {
+    logger6.warn("Skipped malformed lines in correlations.jsonl", {
+      path: filePath,
+      skippedCount,
+      totalLines: lines.length,
+      firstSkipReason
     });
-    return err(
-      new Error(
-        `Unsupported schema version ${String(validation.data.version)} (current: ${String(SCHEMA_VERSION)})`
-      )
-    );
   }
-  return ok(validation.data);
+  return proposals;
 }
-function loadCorrelationData() {
-  const filePath = getCorrelationDataPath();
-  const parseResult = readAndParseFile(filePath);
-  if (!parseResult.ok) return parseResult;
-  const validateResult = validateCorrelationData(parseResult.value, filePath);
-  if (!validateResult.ok) return validateResult;
+function consolidate(legacyProposals, jsonlProposals, maxProposals) {
+  const proposalMap = /* @__PURE__ */ new Map();
+  for (const p of legacyProposals) proposalMap.set(p.proposalId, p);
+  for (const p of jsonlProposals) proposalMap.set(p.proposalId, p);
+  const all = Array.from(proposalMap.values()).sort(
+    (a, b) => a.timestamp.localeCompare(b.timestamp)
+  );
+  return all.length > maxProposals ? all.slice(all.length - maxProposals) : all;
+}
+function loadCorrelationData(config = DEFAULT_HIGHER_ORDER_CONFIG) {
+  const jsonlPath = getCorrelationJsonlPath();
+  const legacyPath = getCorrelationDataPath();
+  const jsonlExists = fs.existsSync(jsonlPath);
+  const legacyExists = fs.existsSync(legacyPath);
+  if (!jsonlExists && !legacyExists) {
+    return err(new Error(`Correlation data file not found: ${jsonlPath}`));
+  }
+  const legacy = loadLegacyJsonProposals();
+  const jsonl = loadJsonlProposals();
+  const proposals = consolidate(legacy, jsonl, config.maxProposals);
   logger6.info("Correlation data loaded", {
-    path: filePath,
-    proposalCount: validateResult.value.proposals.length,
-    savedAt: validateResult.value.savedAt
+    legacyCount: legacy.length,
+    jsonlCount: jsonl.length,
+    afterDedup: proposals.length
+  });
+  return ok({
+    version: SCHEMA_VERSION,
+    proposals,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
-  return validateResult;
 }
 function replayProposals(tracker, proposals) {
   let replayed = 0;
@@ -7800,7 +7842,8 @@ function replayProposals(tracker, proposals) {
 }
 function createPersistentCorrelationTracker(config) {
   const tracker = createCorrelationTracker(config);
-  const loadResult = loadCorrelationData();
+  const mergedConfig = { ...DEFAULT_HIGHER_ORDER_CONFIG, ...config };
+  const loadResult = loadCorrelationData(mergedConfig);
   if (!loadResult.ok) {
     logger6.info("Starting with fresh correlation tracker", {
       reason: loadResult.error.message
@@ -7965,7 +8008,7 @@ function applyErrorPolicy(votes, policy) {
 }
 
 // src/orchestration/outcomes/outcome-store-persistence.ts
-import { appendFileSync as appendFileSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3 } from "fs";
+import { appendFileSync as appendFileSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3 } from "fs";
 var PersistentOutcomeStore = class extends OutcomeStore {
   filePath;
   logger;
@@ -8075,7 +8118,7 @@ var PersistentOutcomeStore = class extends OutcomeStore {
   }
   persistLine(outcome) {
     try {
-      appendFileSync2(this.filePath, JSON.stringify(outcome) + "\n", "utf-8");
+      appendFileSync3(this.filePath, JSON.stringify(outcome) + "\n", "utf-8");
     } catch (error) {
       const msg = getErrorMessage(error);
       this.logger.warn("Failed to persist outcome to disk", {
@@ -8678,7 +8721,7 @@ async function processVotesWithCascade(engineVotes, opts) {
 var CONTRARIAN_ESCALATION_THRESHOLD = 0.8;
 async function runContrarianCheck(proposal, log) {
   try {
-    const { executeExpert } = await import("./expert-bridge-J5ZKCYL5.js");
+    const { executeExpert } = await import("./expert-bridge-FHPWDFJX.js");
     const prompt = [
       "You are a contrarian analyst. Your job is to find reasons this proposal should be REJECTED.",
       "Look for: YAGNI (not needed), MISALIGNED (wrong tech/architecture), SECURITY_RISK, SCOPE_CREEP.",
@@ -8706,7 +8749,9 @@ async function runContrarianCheck(proposal, log) {
       return { shouldEscalate: true, reason: reasoning, confidence };
     }
     return { shouldEscalate: false, reason: "", confidence };
-  } catch {
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.warn("Contrarian check failed; defaulting to no escalation", { error: message });
     return { shouldEscalate: false, reason: "", confidence: 0 };
   }
 }
@@ -9095,4 +9140,4 @@ export {
   CONSENSUS_VOTE_OUTPUT_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-R2VJY7Z4.js.map
+//# sourceMappingURL=chunk-4BXQ2OZY.js.map