nexus-agents 3.9.2 → 3.9.4

package/dist/{child-mcp-config-XIZWCWS3.js → child-mcp-config-MJNB5GXS.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-SNJNRDKZ.js";
 import {
   createLogger
-} from "./chunk-65WAPYJ6.js";
+} from "./chunk-6VUIQQ3O.js";
 import "./chunk-2HUC6NZN.js";
 import "./chunk-OQLFRJCW.js";
 import "./chunk-ZPWHCABL.js";
@@ -62,4 +62,4 @@ export {
   generateMcpConfig,
   getDefaultAllowedTools
 };
-//# sourceMappingURL=child-mcp-config-XIZWCWS3.js.map
+//# sourceMappingURL=child-mcp-config-MJNB5GXS.js.map

package/dist/{chunk-OJCIP6W5.js → chunk-32AWWH4F.js}

@@ -13,7 +13,7 @@ import {
   lookupInTreeCapability,
   ok,
   resolveRetryAfterMs
-} from "./chunk-65WAPYJ6.js";
+} from "./chunk-6VUIQQ3O.js";
 
 // src/config/model-parameter-support.ts
 function parseClaudeMajorMinor(bareId) {
@@ -834,4 +834,4 @@ export {
   DEFAULT_COLLECT_STREAM_MAX_CHUNKS,
   collectStream
 };
-//# sourceMappingURL=chunk-OJCIP6W5.js.map
+//# sourceMappingURL=chunk-32AWWH4F.js.map

package/dist/{chunk-EZXYOWCX.js → chunk-3WWE26PG.js}

@@ -4,7 +4,7 @@ import {
   err,
   getErrorMessage,
   ok
-} from "./chunk-65WAPYJ6.js";
+} from "./chunk-6VUIQQ3O.js";
 
 // src/scm/types.ts
 var ScmError = class extends Error {
@@ -263,4 +263,4 @@ export {
   ScmError,
   GitHubProvider
 };
-//# sourceMappingURL=chunk-EZXYOWCX.js.map
+//# sourceMappingURL=chunk-3WWE26PG.js.map

package/dist/{chunk-65WAPYJ6.js → chunk-6VUIQQ3O.js}

@@ -2623,7 +2623,7 @@ function setDefaultRegistry(registry) {
 }
 async function reloadDefaultRegistry() {
   globalRegistry = buildDefaultRegistry();
-  const { resetGlobalRegistry } = await import("./unified-registry-FYD2XQ43.js");
+  const { resetGlobalRegistry } = await import("./unified-registry-PKDBZ6FO.js");
   resetGlobalRegistry();
   return globalRegistry;
 }
@@ -4914,6 +4914,7 @@ function declaredOrthogonalityGroup(tool) {
 }
 
 // src/core/task-analysis/capability-gap-detector.ts
+var CAPABILITY_GAP_TYPES = ["tool", "expert", "tool_refusal"];
 var AVAILABLE_TOOLS = new Set(TOOL_MANIFEST.map((t) => t.name));
 var AVAILABLE_EXPERTS = /* @__PURE__ */ new Set([
   "code_expert",
@@ -4972,68 +4973,137 @@ function detectCapabilityGaps(required) {
   };
 }
 
-// src/core/task-analysis/capability-gap-ledger.ts
-var DEFAULT_MAX_ENTRIES = 500;
+// src/core/task-analysis/capability-gap-ledger-persistence.ts
+import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname4 } from "path";
+var DEFAULT_MAX_ENTRIES = 5e3;
+var DEFAULT_RETENTION_DAYS = 90;
 var MAX_EXAMPLE_GOALS = 3;
-function gapKey(type, name) {
-  return `${type}:${name}`;
+function isEntry(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return (
+    // Derived from CAPABILITY_GAP_TYPES, never re-listed here — hardcoding the
+    // union is what made every persisted tool_refusal load as malformed.
+    // The array is widened rather than the value asserted: `includes` on a
+    // readonly tuple will not accept `unknown`, and asserting the value would
+    // claim a narrowing this guard has not yet done.
+    typeof v["type"] === "string" && CAPABILITY_GAP_TYPES.includes(v["type"]) && typeof v["name"] === "string" && typeof v["suggestion"] === "string" && typeof v["timestamp"] === "string"
+  );
 }
-function summarizeEntries(entries) {
+function summarize(entries) {
   const groups = /* @__PURE__ */ new Map();
-  for (const e of entries) {
-    const key = gapKey(e.type, e.name);
-    const group = groups.get(key);
-    if (group === void 0) {
-      groups.set(key, {
-        type: e.type,
-        name: e.name,
-        count: 1,
-        suggestion: e.suggestion,
-        goals: new Set(e.goal !== void 0 ? [e.goal] : [])
-      });
-    } else {
-      group.count += 1;
-      group.suggestion = e.suggestion;
-      if (e.goal !== void 0) group.goals.add(e.goal);
+  for (const entry of entries) {
+    const key = `${entry.type}:${entry.name}`;
+    const group = groups.get(key) ?? {
+      type: entry.type,
+      name: entry.name,
+      count: 0,
+      suggestion: entry.suggestion,
+      goals: []
+    };
+    group.count += 1;
+    group.suggestion = entry.suggestion;
+    if (entry.goal !== void 0 && entry.goal !== "" && !group.goals.includes(entry.goal) && group.goals.length < MAX_EXAMPLE_GOALS) {
+      group.goals.push(entry.goal);
     }
+    groups.set(key, group);
   }
   return [...groups.values()].map((g) => ({
     type: g.type,
     name: g.name,
     count: g.count,
     suggestion: g.suggestion,
-    exampleGoals: [...g.goals].slice(0, MAX_EXAMPLE_GOALS)
-  })).sort((a, b) => b.count !== a.count ? b.count - a.count : a.name.localeCompare(b.name));
+    exampleGoals: g.goals
+  })).sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
 }
-function createCapabilityGapLedger(maxEntries = DEFAULT_MAX_ENTRIES) {
+function loadEntries(filePath, cutoff, maxEntries) {
   const entries = [];
+  let malformedLines = 0;
+  let expiredEntries = 0;
+  const fileExisted = existsSync5(filePath);
+  if (!fileExisted) {
+    return { entries, report: { fileExisted, loaded: 0, malformedLines: 0, expiredEntries: 0 } };
+  }
+  let raw = "";
+  try {
+    raw = readFileSync4(filePath, "utf-8");
+  } catch {
+    raw = "";
+  }
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      malformedLines += 1;
+      continue;
+    }
+    if (!isEntry(parsed)) {
+      malformedLines += 1;
+      continue;
+    }
+    if (Date.parse(parsed.timestamp) < cutoff) {
+      expiredEntries += 1;
+      continue;
+    }
+    entries.push(parsed);
+  }
+  if (entries.length > maxEntries) entries.splice(0, entries.length - maxEntries);
+  return {
+    entries,
+    report: { fileExisted, loaded: entries.length, malformedLines, expiredEntries }
+  };
+}
+function createPersistentCapabilityGapLedger(config) {
+  const maxEntries = config.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  const retentionMs = (config.retentionDays ?? DEFAULT_RETENTION_DAYS) * 24 * 60 * 60 * 1e3;
+  const cutoff = getTimeProvider().now() - retentionMs;
+  const { entries, report: loadReport } = loadEntries(config.filePath, cutoff, maxEntries);
   return {
     record(report, context) {
+      if (report.gaps.length === 0) return;
       const timestamp = new Date(getTimeProvider().now()).toISOString();
+      const lines = [];
       for (const gap of report.gaps) {
-        entries.push({
+        const entry = {
           type: gap.type,
           name: gap.name,
           suggestion: gap.suggestion,
           goal: context?.goal,
           timestamp
-        });
+        };
+        entries.push(entry);
+        lines.push(JSON.stringify(entry));
       }
-      if (entries.length > maxEntries) {
-        entries.splice(0, entries.length - maxEntries);
+      if (entries.length > maxEntries) entries.splice(0, entries.length - maxEntries);
+      try {
+        mkdirSync2(dirname4(config.filePath), { recursive: true });
+        appendFileSync(config.filePath, `${lines.join("\n")}
+`, "utf-8");
+      } catch {
       }
     },
     summarize() {
-      return summarizeEntries(entries);
+      return summarize(entries);
     },
     size() {
       return entries.length;
+    },
+    loadReport() {
+      return loadReport;
     }
   };
 }
+
+// src/core/task-analysis/capability-gap-ledger.ts
 var singletonLedger;
 function getGapLedger() {
-  singletonLedger ??= createCapabilityGapLedger();
+  singletonLedger ??= createPersistentCapabilityGapLedger({
+    filePath: nexusDataPath("capability-gaps.jsonl")
+  });
   return singletonLedger;
 }
 function recordRoutingGaps(source, context, ledger = getGapLedger()) {
@@ -12026,8 +12096,8 @@ function aggregateDecisionCosts(records, windowMs) {
 import { z as z17 } from "zod";
 
 // src/config/jsonl-store.ts
-import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname4 } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname5 } from "path";
 var DIR_MODE = 448;
 var JsonlStore = class {
   filePath;
@@ -12080,7 +12150,7 @@ var JsonlStore = class {
   // ==========================================================================
   ensureDir() {
     try {
-      mkdirSync2(dirname4(this.filePath), { recursive: true, mode: DIR_MODE });
+      mkdirSync3(dirname5(this.filePath), { recursive: true, mode: DIR_MODE });
     } catch (error) {
       this.logger.warn("Failed to create JSONL store directory", {
         error: getErrorMessage(error),
@@ -12089,14 +12159,14 @@ var JsonlStore = class {
     }
   }
   hydrate() {
-    if (!existsSync5(this.filePath)) {
+    if (!existsSync6(this.filePath)) {
       this.logger.debug("No JSONL file found, starting fresh", { path: this.filePath });
       return;
     }
     let loaded = 0;
     let skipped = 0;
     try {
-      const content = readFileSync4(this.filePath, "utf-8");
+      const content = readFileSync5(this.filePath, "utf-8");
       const lines = content.split("\n").filter((line) => line.trim().length > 0);
       for (const line of lines) {
         try {
@@ -12132,7 +12202,7 @@ var JsonlStore = class {
   }
   persistLine(record) {
     try {
-      appendFileSync(this.filePath, JSON.stringify(record) + "\n", "utf-8");
+      appendFileSync2(this.filePath, JSON.stringify(record) + "\n", "utf-8");
       return true;
     } catch (error) {
       this.logger.warn("Failed to append JSONL record to disk", {
@@ -12390,7 +12460,7 @@ var DecisionCostStore = class {
 };
 
 // src/orchestration/strategy-manifest.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
 import { parse as parseYaml2 } from "yaml";
 import { z as z18 } from "zod";
 var STRATEGY_MANIFEST_SCHEMA_VERSION = 1;
@@ -14269,7 +14339,7 @@ function resolveModelForTier(cliName, tier, opts = {}) {
 }
 
 // src/cli-adapters/model-selection-shadow.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
 import { z as z21 } from "zod";
 function isRouteModelShadowEnabled() {
   return process.env["NEXUS_ROUTE_MODEL_SHADOW"] === "1" && isPersistenceEnabled();
@@ -14310,7 +14380,7 @@ var persistLogger = createLogger({ component: "ModelSelectionShadow" });
 function persistModelSelectionShadowRecord(record) {
   try {
     ensureLearningDir();
-    appendFileSync2(getModelSelectionShadowFile(), JSON.stringify(record) + "\n", "utf-8");
+    appendFileSync3(getModelSelectionShadowFile(), JSON.stringify(record) + "\n", "utf-8");
   } catch (err2) {
     recordModelSelectionShadowFailure();
     persistLogger.warn("Failed to persist model-selection shadow record (ignored)", {
@@ -14320,11 +14390,11 @@ function persistModelSelectionShadowRecord(record) {
 }
 function readModelSelectionShadowRecords() {
   const file = getModelSelectionShadowFile();
-  if (!existsSync7(file)) return [];
+  if (!existsSync8(file)) return [];
   const records = [];
   try {
     const cutoff = Date.now() - READ_LOOKBACK_MS;
-    const lines = readFileSync6(file, "utf-8").split("\n").filter((l) => l.trim().length > 0);
+    const lines = readFileSync7(file, "utf-8").split("\n").filter((l) => l.trim().length > 0);
     for (const line of lines) {
       let parsed;
       try {
@@ -14835,7 +14905,7 @@ var CompositeRouter = class _CompositeRouter {
    */
   async consultUnifiedContext(task) {
     try {
-      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-BJL3MZTY.js");
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-JNXUAPWJ.js");
       const ctx = await getContextForTask({
         task: task.content,
         category: inferTaskCategory(task.content),
@@ -15329,8 +15399,8 @@ var OrchestratorError = class extends Error {
 
 // src/context/mobimem.ts
 import Database from "better-sqlite3";
-import { dirname as dirname5 } from "path";
-import { mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname6 } from "path";
+import { mkdirSync as mkdirSync4 } from "fs";
 
 // src/context/mobimem-types.ts
 import { z as z22 } from "zod";
@@ -15821,7 +15891,7 @@ var MobiMem = class {
     if (validated.dbPath === ":memory:" || validated.dbPath === "") {
       this.db = null;
     } else {
-      mkdirSync3(dirname5(validated.dbPath), { recursive: true });
+      mkdirSync4(dirname6(validated.dbPath), { recursive: true });
       const db = new Database(validated.dbPath);
       db.pragma("journal_mode = WAL");
       this.db = db;
@@ -16424,4 +16494,4 @@ export {
   AgentCapability,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-65WAPYJ6.js.map
+//# sourceMappingURL=chunk-6VUIQQ3O.js.map