@serkanalgur/opencode-nexus 2.4.0 → 2.4.1

package/dist/index.js

@@ -8366,7 +8366,7 @@ var Event16 = { Updated: Updated12, Resolved, Definitions: inventory(Updated12,
 // src/config.ts
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, dirname } from "node:path";
+import { join, dirname, resolve as resolve2 } from "node:path";
 function stripJsonComments(jsonc) {
   const result = [];
   let i = 0;
@@ -8414,14 +8414,46 @@ function readJsoncFile(filePath) {
     const raw = readFileSync(filePath, "utf-8");
     const stripped = stripJsonComments(raw);
     const parsed = JSON.parse(stripped);
-    return parsed;
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      console.warn(`[nexus] Ignoring config from ${filePath}: expected a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}`);
+      return { config: null, existed: true };
+    }
+    return { config: parsed, existed: true };
   } catch (err) {
-    if (err.code !== "ENOENT") {
-      console.warn(`[nexus] Failed to load config from ${filePath}: ${err.message}`);
+    const code = err.code;
+    const message = err instanceof Error ? err.message : String(err);
+    const absent = code === "ENOENT" || code === "ENOTDIR";
+    if (!absent) {
+      console.warn(`[nexus] Failed to load config from ${filePath}: ${message}`);
     }
-    return null;
+    return { config: null, existed: !absent };
   }
 }
+function nexusProjectConfigPath(basePath) {
+  return resolve2(join(basePath, ".opencode", "nexus.jsonc"));
+}
+function nexusGlobalConfigPath() {
+  return resolve2(join(homedir(), ".config", "opencode", "nexus.jsonc"));
+}
+function redactHome(filePath) {
+  const home = homedir();
+  if (filePath === home)
+    return "~";
+  const prefix = home.endsWith("/") ? home : `${home}/`;
+  return filePath.startsWith(prefix) ? `~${filePath.slice(home.length)}` : filePath;
+}
+function describeFile(file) {
+  if (file.parsed)
+    return "loaded";
+  if (file.existed)
+    return "unparseable";
+  return "absent";
+}
+function formatConfigLoadLog(info) {
+  const models = Object.entries(info.models).map(([role, model]) => `${role}=${model}`).join(" ");
+  const override = info.sessionOverride ? " (+session override: storage; disk edits to models are IGNORED while a preset is set — clear the preset in the TUI to hand control back to disk)" : "";
+  return `[nexus] config loaded (#${info.loadCount} trigger=${info.trigger} at=${info.loadedAt}) ` + `project=${info.project.path} [${describeFile(info.project)}] ` + `global=${info.global.path} [${describeFile(info.global)}] ` + `models:${override} ${models}`;
+}
 var DEFAULT_CONFIG = {
   models: {
     architect: "anthropic/claude-sonnet-4-6",
@@ -8448,19 +8480,51 @@ class NexusConfigManager {
   projectConfig = null;
   globalConfig = null;
   storageConfig = null;
+  loadInfo = null;
   constructor() {
     this.projectConfig = null;
     this.globalConfig = null;
   }
   loadConfigs(basePath) {
-    this.storageConfig = null;
-    const projectPath = join(basePath, ".opencode", "nexus.jsonc");
-    this.projectConfig = readJsoncFile(projectPath);
-    const globalPath = join(homedir(), ".config", "opencode", "nexus.jsonc");
-    this.globalConfig = readJsoncFile(globalPath);
+    if (this.loadInfo === null)
+      this.storageConfig = null;
+    const projectPath = nexusProjectConfigPath(basePath);
+    const project = readJsoncFile(projectPath);
+    this.projectConfig = project.config;
+    const globalPath = nexusGlobalConfigPath();
+    const global = readJsoncFile(globalPath);
+    this.globalConfig = global.config;
+    return {
+      project: { path: redactHome(projectPath), existed: project.existed, parsed: project.config !== null },
+      global: { path: redactHome(globalPath), existed: global.existed, parsed: global.config !== null }
+    };
+  }
+  loadFromPath(basePath, trigger = "initial") {
+    const sources = this.loadConfigs(basePath);
+    this.loadInfo = {
+      project: sources.project,
+      global: sources.global,
+      models: this.getResolvedModels(),
+      sessionOverride: this.hasSessionOverride(),
+      loadedAt: new Date().toISOString(),
+      loadCount: (this.loadInfo?.loadCount ?? 0) + 1,
+      trigger
+    };
+    console.log(formatConfigLoadLog(this.loadInfo));
   }
-  loadFromPath(basePath) {
-    this.loadConfigs(basePath);
+  getLoadInfo() {
+    return this.loadInfo;
+  }
+  getResolvedModels() {
+    const models = {};
+    for (const [role, model] of Object.entries(this.getConfig().models)) {
+      if (model)
+        models[role] = model;
+    }
+    return models;
+  }
+  hasSessionOverride() {
+    return this.storageConfig !== null;
   }
   getConfig() {
     return {
@@ -8563,17 +8627,17 @@ class NexusConfigManager {
 `, "utf-8");
   }
   saveProjectConfig(basePath) {
-    const projectPath = join(basePath, ".opencode", "nexus.jsonc");
+    const projectPath = nexusProjectConfigPath(basePath);
     const config = this.getSaveableConfig();
     this.writeJsoncFile(projectPath, config);
   }
   saveGlobalConfig() {
-    const globalPath = join(homedir(), ".config", "opencode", "nexus.jsonc");
+    const globalPath = nexusGlobalConfigPath();
     const config = this.getSaveableConfig();
     this.writeJsoncFile(globalPath, config);
   }
   initProjectConfig(basePath) {
-    const projectPath = join(basePath, ".opencode", "nexus.jsonc");
+    const projectPath = nexusProjectConfigPath(basePath);
     try {
       readFileSync(projectPath, "utf-8");
       return;
@@ -8581,7 +8645,7 @@ class NexusConfigManager {
     this.writeJsoncFile(projectPath, { ...DEFAULT_CONFIG });
   }
   initGlobalConfig() {
-    const globalPath = join(homedir(), ".config", "opencode", "nexus.jsonc");
+    const globalPath = nexusGlobalConfigPath();
     try {
       readFileSync(globalPath, "utf-8");
       return;
@@ -10362,6 +10426,21 @@ class NexusOrchestrator {
       this.onStateChange?.();
     }, 100);
   }
+  reloadConfigFromDisk(trigger = "event") {
+    const projectDir = this.ctx?.location.directory;
+    if (projectDir) {
+      this.configManager.loadFromPath(projectDir, trigger);
+    }
+    const info = this.configManager.getLoadInfo();
+    if (info) {
+      this.notifyStateChange();
+      this.emit("config:reloaded", info);
+    }
+    return info;
+  }
+  getConfigInfo() {
+    return this.configManager.getLoadInfo();
+  }
   async execute(request) {
     if (this.running) {
       throw new Error("Orchestrator is already running");
@@ -10394,6 +10473,7 @@ class NexusOrchestrator {
         agentsUsed: this.agents.size
       };
     } catch (error) {
+      console.error("[nexus] DAG execution failed:", error);
       return {
         success: false,
         tasks: [],
@@ -10489,7 +10569,21 @@ class NexusOrchestrator {
       const spawnPromises = [];
       for (const node of readyNodes) {
         if (this.agents.size < this.config.maxConcurrency) {
-          spawnPromises.push(this.spawnAndExecute(node));
+          spawnPromises.push(this.spawnAndExecute(node).catch((error) => {
+            const err = error instanceof Error ? error : new Error(String(error));
+            node.status = "failed";
+            node.task.status = "failed";
+            node.result = { success: false, error: err.message, duration: 0, tokensUsed: 0, cost: 0 };
+            this.dag.markFailed(node.id, err);
+            this.notifyStateChange();
+            this.emit("task:failed", {
+              taskId: node.id,
+              taskName: node.task.name,
+              role: node.task.requiredRole,
+              error: err.message,
+              duration: 0
+            });
+          }));
         }
       }
       await Promise.all(spawnPromises);
@@ -10499,10 +10593,15 @@ class NexusOrchestrator {
   async spawnAndExecute(node, transferContext) {
     const complexity = this.analyzeComplexity(node.task);
     const model = this.selectModel(node.task.requiredRole, complexity);
+    if (!model.provider || !model.model) {
+      const missing = !model.provider && !model.model ? "provider and model" : !model.provider ? "provider" : "model";
+      throw new Error(`Model selection for role "${node.task.requiredRole}" is missing its ${missing}: ` + `got { provider: ${JSON.stringify(model.provider)}, model: ${JSON.stringify(model.model)} }. ` + `Cannot build a "providerID/modelID" reference.`);
+    }
+    const qualifiedModel = `${model.provider}/${model.model}`;
     const agent = await this.spawnAgent({
       role: node.task.requiredRole,
       task: node.task,
-      model: model.model
+      model: qualifiedModel
     });
     node.spawnedAgent = agent;
     node.status = "running";
@@ -10829,7 +10928,8 @@ Please continue from where the previous agent left off.`;
       if (match) {
         modelConfig = match;
       } else {
-        throw new Error(`Invalid model "${config.model}". Use "providerID/modelID" format (e.g. "opencode-go/mimo-v2.5")`);
+        const source = config.model ? "requested" : "configured for role";
+        throw new Error(`Invalid model "${modelConfig}" (${source} "${config.role}"). Use "providerID/modelID" format (e.g. "opencode-go/mimo-v2.5")`);
       }
     }
     const slashIndex = modelConfig.indexOf("/");
@@ -11138,8 +11238,20 @@ Please continue from where the previous agent left off.`;
   }
   getStatus(detailed) {
     const state = this.getState();
+    const loadInfo = this.configManager.getLoadInfo();
+    const config = {
+      loaded: loadInfo !== null,
+      loadedAt: loadInfo?.loadedAt ?? null,
+      loadCount: loadInfo?.loadCount ?? 0,
+      sessionOverride: this.configManager.hasSessionOverride(),
+      diskModelsIgnored: this.configManager.hasSessionOverride(),
+      trigger: loadInfo?.trigger ?? null,
+      project: loadInfo?.project ?? null,
+      global: loadInfo?.global ?? null,
+      models: this.configManager.getResolvedModels()
+    };
     if (detailed)
-      return JSON.stringify({ ...state, budgetExceeded: this.budgetExceeded }, null, 2);
+      return JSON.stringify({ ...state, budgetExceeded: this.budgetExceeded, config }, null, 2);
     return JSON.stringify({
       running: state.running,
       paused: state.paused,
@@ -11147,7 +11259,8 @@ Please continue from where the previous agent left off.`;
       agents: state.agents.length,
       tasks: state.tasks.length,
       totalCost: state.totalSpent,
-      budgetRemaining: state.budgetRemaining
+      budgetRemaining: state.budgetRemaining,
+      config
     }, null, 2);
   }
   listAgents(filter) {
@@ -11557,9 +11670,126 @@ class AstGrep {
 }
 
 // src/index.ts
-import { writeFileSync as writeFileSync2, readFileSync as readFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync3 } from "node:fs";
-import { join as join6 } from "node:path";
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync3, statSync } from "node:fs";
+import { join as join6, resolve as resolve3, basename, dirname as dirname4 } from "node:path";
 import { homedir as homedir2 } from "node:os";
+var CONFIG_RELOAD_DEBOUNCE_MS = 150;
+var CONFIG_POLL_INTERVAL_MS = 2000;
+function isNexusConfigFile(file, eventDirectory, projectDirectory, projectPath, globalPath) {
+  const resolved = resolve3(file);
+  if (resolved === projectPath || resolved === globalPath)
+    return true;
+  if (eventDirectory !== undefined && resolve3(eventDirectory) !== projectDirectory)
+    return false;
+  return basename(resolved) === "nexus.jsonc" && basename(dirname4(resolved)) === ".opencode";
+}
+var watchedContexts = new WeakSet;
+var MAX_RELOAD_WAIT_MS = 1000;
+var MIN_INTERVAL_MS = 25;
+var clampInterval = (ms, fallback) => Number.isFinite(ms) && ms >= MIN_INTERVAL_MS ? ms : fallback;
+function watchConfigFiles(ctx, orchestrator, debounceMs = CONFIG_RELOAD_DEBOUNCE_MS, pollMs = CONFIG_POLL_INTERVAL_MS) {
+  if (watchedContexts.has(ctx))
+    return () => {};
+  watchedContexts.add(ctx);
+  const debounce = clampInterval(debounceMs, CONFIG_RELOAD_DEBOUNCE_MS);
+  const pollEvery = clampInterval(pollMs, CONFIG_POLL_INTERVAL_MS);
+  const projectDirectory = resolve3(ctx.location.directory);
+  const projectPath = nexusProjectConfigPath(ctx.location.directory);
+  const globalPath = nexusGlobalConfigPath();
+  const watchedPaths = [projectPath, globalPath];
+  const controller = new AbortController;
+  let debounceTimer = null;
+  let firstScheduledAt = 0;
+  const clearPendingReload = () => {
+    if (debounceTimer === null)
+      return;
+    clearTimeout(debounceTimer);
+    debounceTimer = null;
+  };
+  const stampOf = (filePath) => {
+    try {
+      const stats = statSync(filePath);
+      if (!stats.isFile())
+        return "absent";
+      return `${stats.mtimeMs}:${stats.size}`;
+    } catch {
+      return "absent";
+    }
+  };
+  const lastSeen = new Map(watchedPaths.map((p) => [p, stampOf(p)]));
+  const runReload = (trigger) => {
+    for (const filePath of watchedPaths)
+      lastSeen.set(filePath, stampOf(filePath));
+    try {
+      orchestrator.reloadConfigFromDisk(trigger);
+    } catch (err) {
+      console.warn(`[nexus] config reload failed (${trigger}): ${String(err)}`);
+    }
+  };
+  const scheduleReload = (trigger) => {
+    const pending = debounceTimer !== null;
+    const waited = pending ? Date.now() - firstScheduledAt : 0;
+    clearPendingReload();
+    if (pending && waited >= MAX_RELOAD_WAIT_MS) {
+      runReload(trigger);
+      return;
+    }
+    if (!pending)
+      firstScheduledAt = Date.now();
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      runReload(trigger);
+    }, debounce);
+  };
+  const poll = () => {
+    let changed = false;
+    for (const filePath of watchedPaths) {
+      const current = stampOf(filePath);
+      if (lastSeen.get(filePath) === current)
+        continue;
+      lastSeen.set(filePath, current);
+      changed = true;
+    }
+    if (changed)
+      scheduleReload("poll");
+  };
+  const pollTimer = setInterval(poll, pollEvery);
+  pollTimer.unref();
+  const eventDomain = ctx.event;
+  if (typeof eventDomain?.subscribe !== "function") {
+    console.warn("[nexus] no config event stream on this context; polling is the only config reload trigger");
+    return () => {
+      clearInterval(pollTimer);
+      clearPendingReload();
+      controller.abort();
+    };
+  }
+  const consume = async () => {
+    try {
+      for await (const event of eventDomain.subscribe({ signal: controller.signal })) {
+        if (event.type !== "filesystem.changed")
+          continue;
+        const file = event.data?.file;
+        if (typeof file !== "string")
+          continue;
+        if (!isNexusConfigFile(file, event.location?.directory, projectDirectory, projectPath, globalPath))
+          continue;
+        scheduleReload("event");
+      }
+      if (!controller.signal.aborted) {
+        console.warn("[nexus] config event stream ended; polling remains the only config reload trigger");
+      }
+    } catch (err) {
+      console.warn(`[nexus] config event stream failed; polling remains the only config reload trigger: ${String(err)}`);
+    }
+  };
+  consume();
+  return () => {
+    clearInterval(pollTimer);
+    clearPendingReload();
+    controller.abort();
+  };
+}
 var NEXUS_AGENT_CONTENT = `---
 description: Nexus multi-agent orchestrator — decomposes tasks and delegates to specialized sub-agents
 mode: primary
@@ -12089,7 +12319,7 @@ You are a technical writer who creates documentation that developers actually wa
       });
       editor.add({
         name: "status",
-        description: "Get orchestrator status and metrics",
+        description: "Get orchestrator status, metrics, and the config files currently in effect (paths consulted, which existed, resolved role -> model map)",
         input: {
           type: "object",
           properties: {
@@ -12228,7 +12458,10 @@ You are a technical writer who creates documentation that developers actually wa
           const { name } = input;
           try {
             orchestrator.configManager.applyPreset(name);
-            return { content: `Applied preset: ${PRESETS[name]?.name || name}` };
+            return {
+              content: `Applied preset: ${PRESETS[name]?.name || name}
+` + `⚠️ This preset now overrides the \`models\` section of nexus.jsonc. ` + `Edits to models in the config file will NOT take effect until the preset is cleared. ` + `Clear it from the TUI (config manager) to hand control back to disk. ` + `Budget and self-healing values from the file still apply.`
+            };
           } catch (error) {
             return { content: `Error: ${error.message}` };
           }
@@ -13201,19 +13434,24 @@ ${lines.join(`
         event.metadata = { ...event.metadata, nexusResult: result };
       }
     });
+    const stopConfigWatch = watchConfigFiles(ctx, orchestrator);
     return () => {
+      stopConfigWatch();
       orchestrator.shutdown();
     };
   }
 });
 export {
   AstGrep,
+  CONFIG_POLL_INTERVAL_MS,
+  CONFIG_RELOAD_DEBOUNCE_MS,
   CostForecaster,
   CustomRoleManager,
   DEFAULT_CONFIG,
   GoalManager,
   HealthMonitor,
   LearningModule,
+  MAX_RELOAD_WAIT_MS,
   MessageRouter,
   MessageStore,
   ModuleRegistry,
@@ -13232,5 +13470,6 @@ export {
   detectCycles,
   getTemplate,
   instantiateTemplate,
-  listTemplates
+  listTemplates,
+  watchConfigFiles
 };

package/dist/tui.js

@@ -9,7 +9,7 @@ var PluginContext = createContext();
 // src/config.ts
 import { readFileSync, writeFileSync, mkdirSync } from "fs";
 import { homedir } from "os";
-import { join, dirname } from "path";
+import { join, dirname, resolve } from "path";
 function stripJsonComments(jsonc) {
   const result = [];
   let i = 0;
@@ -57,14 +57,46 @@ function readJsoncFile(filePath) {
     const raw = readFileSync(filePath, "utf-8");
     const stripped = stripJsonComments(raw);
     const parsed = JSON.parse(stripped);
-    return parsed;
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      console.warn(`[nexus] Ignoring config from ${filePath}: expected a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}`);
+      return { config: null, existed: true };
+    }
+    return { config: parsed, existed: true };
   } catch (err) {
-    if (err.code !== "ENOENT") {
-      console.warn(`[nexus] Failed to load config from ${filePath}: ${err.message}`);
+    const code = err.code;
+    const message = err instanceof Error ? err.message : String(err);
+    const absent = code === "ENOENT" || code === "ENOTDIR";
+    if (!absent) {
+      console.warn(`[nexus] Failed to load config from ${filePath}: ${message}`);
     }
-    return null;
+    return { config: null, existed: !absent };
   }
 }
+function nexusProjectConfigPath(basePath) {
+  return resolve(join(basePath, ".opencode", "nexus.jsonc"));
+}
+function nexusGlobalConfigPath() {
+  return resolve(join(homedir(), ".config", "opencode", "nexus.jsonc"));
+}
+function redactHome(filePath) {
+  const home = homedir();
+  if (filePath === home)
+    return "~";
+  const prefix = home.endsWith("/") ? home : `${home}/`;
+  return filePath.startsWith(prefix) ? `~${filePath.slice(home.length)}` : filePath;
+}
+function describeFile(file) {
+  if (file.parsed)
+    return "loaded";
+  if (file.existed)
+    return "unparseable";
+  return "absent";
+}
+function formatConfigLoadLog(info) {
+  const models = Object.entries(info.models).map(([role, model]) => `${role}=${model}`).join(" ");
+  const override = info.sessionOverride ? " (+session override: storage; disk edits to models are IGNORED while a preset is set \u2014 clear the preset in the TUI to hand control back to disk)" : "";
+  return `[nexus] config loaded (#${info.loadCount} trigger=${info.trigger} at=${info.loadedAt}) ` + `project=${info.project.path} [${describeFile(info.project)}] ` + `global=${info.global.path} [${describeFile(info.global)}] ` + `models:${override} ${models}`;
+}
 var DEFAULT_CONFIG = {
   models: {
     architect: "anthropic/claude-sonnet-4-6",
@@ -91,19 +123,51 @@ class NexusConfigManager {
   projectConfig = null;
   globalConfig = null;
   storageConfig = null;
+  loadInfo = null;
   constructor() {
     this.projectConfig = null;
     this.globalConfig = null;
   }
   loadConfigs(basePath) {
-    this.storageConfig = null;
-    const projectPath = join(basePath, ".opencode", "nexus.jsonc");
-    this.projectConfig = readJsoncFile(projectPath);
-    const globalPath = join(homedir(), ".config", "opencode", "nexus.jsonc");
-    this.globalConfig = readJsoncFile(globalPath);
+    if (this.loadInfo === null)
+      this.storageConfig = null;
+    const projectPath = nexusProjectConfigPath(basePath);
+    const project = readJsoncFile(projectPath);
+    this.projectConfig = project.config;
+    const globalPath = nexusGlobalConfigPath();
+    const global = readJsoncFile(globalPath);
+    this.globalConfig = global.config;
+    return {
+      project: { path: redactHome(projectPath), existed: project.existed, parsed: project.config !== null },
+      global: { path: redactHome(globalPath), existed: global.existed, parsed: global.config !== null }
+    };
+  }
+  loadFromPath(basePath, trigger = "initial") {
+    const sources = this.loadConfigs(basePath);
+    this.loadInfo = {
+      project: sources.project,
+      global: sources.global,
+      models: this.getResolvedModels(),
+      sessionOverride: this.hasSessionOverride(),
+      loadedAt: new Date().toISOString(),
+      loadCount: (this.loadInfo?.loadCount ?? 0) + 1,
+      trigger
+    };
+    console.log(formatConfigLoadLog(this.loadInfo));
+  }
+  getLoadInfo() {
+    return this.loadInfo;
+  }
+  getResolvedModels() {
+    const models = {};
+    for (const [role, model] of Object.entries(this.getConfig().models)) {
+      if (model)
+        models[role] = model;
+    }
+    return models;
   }
-  loadFromPath(basePath) {
-    this.loadConfigs(basePath);
+  hasSessionOverride() {
+    return this.storageConfig !== null;
   }
   getConfig() {
     return {
@@ -206,17 +270,17 @@ class NexusConfigManager {
 `, "utf-8");
   }
   saveProjectConfig(basePath) {
-    const projectPath = join(basePath, ".opencode", "nexus.jsonc");
+    const projectPath = nexusProjectConfigPath(basePath);
     const config = this.getSaveableConfig();
     this.writeJsoncFile(projectPath, config);
   }
   saveGlobalConfig() {
-    const globalPath = join(homedir(), ".config", "opencode", "nexus.jsonc");
+    const globalPath = nexusGlobalConfigPath();
     const config = this.getSaveableConfig();
     this.writeJsoncFile(globalPath, config);
   }
   initProjectConfig(basePath) {
-    const projectPath = join(basePath, ".opencode", "nexus.jsonc");
+    const projectPath = nexusProjectConfigPath(basePath);
     try {
       readFileSync(projectPath, "utf-8");
       return;
@@ -224,7 +288,7 @@ class NexusConfigManager {
     this.writeJsoncFile(projectPath, { ...DEFAULT_CONFIG });
   }
   initGlobalConfig() {
-    const globalPath = join(homedir(), ".config", "opencode", "nexus.jsonc");
+    const globalPath = nexusGlobalConfigPath();
     try {
       readFileSync(globalPath, "utf-8");
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serkanalgur/opencode-nexus",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "Adaptive Multi-Agent Orchestration with Cost Intelligence for OpenCode V2",
   "keywords": [
     "opencode",