@intent-systems/nexus 2026.1.5-4 → 2026.1.5-8

package/dist/agents/pi-embedded-runner.js

@@ -1,11 +1,13 @@
 import fs from "node:fs/promises";
 import os from "node:os";
+import { streamSimple } from "@mariozechner/pi-ai";
 import { buildSystemPrompt, createAgentSession, discoverAuthStorage, discoverModels, SessionManager, SettingsManager, } from "@mariozechner/pi-coding-agent";
 import { formatToolAggregate } from "../auto-reply/tool-meta.js";
 import { getMachineDisplayName } from "../infra/machine-name.js";
 import { createSubsystemLogger } from "../logging.js";
 import { splitMediaFromOutput } from "../media/parse.js";
 import { enqueueCommandInLane, } from "../process/command-queue.js";
+import { resolveTelegramReactionLevel } from "../telegram/reaction-level.js";
 import { resolveUserPath } from "../utils.js";
 import { resolveNexusAgentDir } from "./agent-paths.js";
 import { markAuthProfileCooldown, markAuthProfileGood, markAuthProfileUsed, } from "./auth-profiles.js";
@@ -18,7 +20,6 @@ import { extractAssistantText } from "./pi-embedded-utils.js";
 import { toToolDefinitions } from "./pi-tool-definition-adapter.js";
 import { createNexusCodingTools } from "./pi-tools.js";
 import { resolveSandboxContext } from "./sandbox.js";
-import { resolveTelegramReactionLevel } from "../telegram/reaction-level.js";
 import { applySkillEnvOverrides, applySkillEnvOverridesFromSnapshot, buildWorkspaceSkillSnapshot, loadWorkspaceSkillEntries, } from "./skills.js";
 import { buildAgentSystemPromptAppend } from "./system-prompt.js";
 import { normalizeUsage } from "./usage.js";
@@ -46,7 +47,7 @@ const GOOGLE_SCHEMA_UNSUPPORTED_KEYWORDS = new Set([
     "minProperties",
     "maxProperties",
 ]);
-function isAntigravityClaudeModel(provider, modelId) {
+function _isAntigravityClaudeModel(provider, modelId) {
     if (provider !== "google-antigravity")
         return false;
     return modelId.trim().toLowerCase().includes("claude");
@@ -69,8 +70,9 @@ function findUnsupportedSchemaKeywords(schema, path) {
     }
     return violations;
 }
-function logToolSchemasForGoogle(params) {
-    if (params.provider !== "google-antigravity" && params.provider !== "google-gemini-cli") {
+function _logToolSchemasForGoogle(params) {
+    if (params.provider !== "google-antigravity" &&
+        params.provider !== "google-gemini-cli") {
         return;
     }
     const toolNames = params.tools.map((tool, index) => `${index}:${tool.name}`);
@@ -91,6 +93,89 @@ function logToolSchemasForGoogle(params) {
         }
     }
 }
+/**
+ * Resolve provider-specific extra params from model config.
+ *
+ * Example config:
+ *   agent.models["anthropic/claude-sonnet-4-5"].params.temperature = 0.7
+ *   agent.models["openai/gpt-4.1-mini"].params.maxTokens = 8192
+ */
+export function resolveExtraParams(params) {
+    const modelKey = `${params.provider}/${params.modelId}`;
+    const modelConfig = params.cfg?.agent?.models?.[modelKey];
+    let extraParams = modelConfig?.params ? { ...modelConfig.params } : undefined;
+    // Auto-enable thinking for ZAI GLM-4.x models when not explicitly configured.
+    // Skip if user explicitly disabled thinking via --thinking off.
+    if (params.provider === "zai" && params.thinkLevel !== "off") {
+        const modelIdLower = params.modelId.toLowerCase();
+        const isGlm4 = modelIdLower.includes("glm-4");
+        if (isGlm4) {
+            const hasThinkingConfig = extraParams?.thinking !== undefined;
+            if (!hasThinkingConfig) {
+                // GLM-4.7 supports preserved thinking (reasoning kept across turns).
+                // GLM-4.5/4.6 use interleaved thinking (reasoning cleared each turn).
+                const isGlm47 = modelIdLower.includes("glm-4.7");
+                const clearThinking = !isGlm47;
+                extraParams = {
+                    ...extraParams,
+                    thinking: {
+                        type: "enabled",
+                        clear_thinking: clearThinking,
+                    },
+                };
+                log.debug(`auto-enabled thinking for ${modelKey}: type=enabled, clear_thinking=${clearThinking}`);
+            }
+        }
+    }
+    return extraParams;
+}
+/**
+ * Create a wrapped streamFn that injects extra params (like temperature) from config.
+ *
+ * This wraps the default streamSimple with config-driven params for each model.
+ */
+function createStreamFnWithExtraParams(extraParams) {
+    if (!extraParams || Object.keys(extraParams).length === 0) {
+        return undefined;
+    }
+    const streamParams = {};
+    if (typeof extraParams.temperature === "number") {
+        streamParams.temperature = extraParams.temperature;
+    }
+    if (typeof extraParams.maxTokens === "number") {
+        streamParams.maxTokens = extraParams.maxTokens;
+    }
+    if (Object.keys(streamParams).length === 0) {
+        return undefined;
+    }
+    log.debug(`creating streamFn wrapper with params: ${JSON.stringify(streamParams)}`);
+    const wrappedStreamFn = (model, context, options) => {
+        const mergedOptions = {
+            ...streamParams,
+            ...options,
+        };
+        return streamSimple(model, context, mergedOptions);
+    };
+    return wrappedStreamFn;
+}
+/**
+ * Apply extra params (like temperature) to an agent's streamFn.
+ *
+ * Call this after createAgentSession to wire up config-driven model params.
+ */
+function applyExtraParamsToAgent(agent, cfg, provider, modelId, thinkLevel) {
+    const extraParams = resolveExtraParams({
+        cfg,
+        provider,
+        modelId,
+        thinkLevel,
+    });
+    const wrappedStreamFn = createStreamFnWithExtraParams(extraParams);
+    if (wrappedStreamFn) {
+        log.debug(`applying extraParams to agent streamFn for ${provider}/${modelId}`);
+        agent.streamFn = wrappedStreamFn;
+    }
+}
 /**
  * Limits conversation history to the last N user turns (and their associated
  * assistant responses). This reduces token usage for long-running DM sessions.
@@ -136,7 +221,9 @@ export function getDmHistoryLimitFromSessionKey(sessionKey, config, messageChann
     const raw = sessionKey?.trim() ?? "";
     if (!raw)
         return undefined;
-    if (raw.startsWith("group:") || raw.includes(":group:") || raw.includes(":channel:")) {
+    if (raw.startsWith("group:") ||
+        raw.includes(":group:") ||
+        raw.includes(":channel:")) {
         return undefined;
     }
     const parts = raw.split(":").filter(Boolean);
@@ -176,7 +263,7 @@ export function getDmHistoryLimitFromSessionKey(sessionKey, config, messageChann
             return undefined;
     }
 }
-function resolveReactionGuidance(params) {
+function _resolveReactionGuidance(params) {
     if (!params.config)
         return undefined;
     const rawChannel = params.messageChannel ?? params.messageProvider ?? "";
@@ -488,6 +575,7 @@ export async function compactEmbeddedPiSession(params) {
                 skills: promptSkills,
                 contextFiles,
             });
+            applyExtraParamsToAgent(session.agent, params.config, provider, modelId, params.thinkLevel);
             try {
                 const prior = await sanitizeSessionMessagesImages(session.messages, "session:history");
                 if (prior.length > 0) {
@@ -705,6 +793,7 @@ export async function runEmbeddedPiAgent(params) {
                     skills: promptSkills,
                     contextFiles,
                 });
+                applyExtraParamsToAgent(session.agent, params.config, provider, modelId, thinkLevel);
                 const prior = await sanitizeSessionMessagesImages(session.messages, "session:history");
                 if (prior.length > 0) {
                     session.agent.replaceMessages(prior);
@@ -837,7 +926,7 @@ export async function runEmbeddedPiAgent(params) {
                 if (shouldRotate) {
                     // Mark current profile for cooldown before rotating
                     if (lastProfileId) {
-                        markAuthProfileCooldown({
+                        void markAuthProfileCooldown({
                             store: authStore,
                             profileId: lastProfileId,
                         });
@@ -906,13 +995,16 @@ export async function runEmbeddedPiAgent(params) {
                     .filter((p) => p.text || p.mediaUrl || (p.mediaUrls && p.mediaUrls.length > 0));
                 log.debug(`embedded run done: runId=${params.runId} sessionId=${params.sessionId} durationMs=${Date.now() - started} aborted=${aborted}`);
                 if (lastProfileId) {
-                    markAuthProfileGood({
+                    void markAuthProfileGood({
                         store: authStore,
                         provider,
                         profileId: lastProfileId,
                     });
                     // Track usage for round-robin rotation
-                    markAuthProfileUsed({ store: authStore, profileId: lastProfileId });
+                    void markAuthProfileUsed({
+                        store: authStore,
+                        profileId: lastProfileId,
+                    });
                 }
                 return {
                     payloads: payloads.length ? payloads : undefined,

package/dist/agents/sandbox.js

@@ -4,7 +4,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { startBrowserBridgeServer, stopBrowserBridgeServer, } from "../browser/bridge-server.js";
-import { resolveProfile } from "../browser/config.js";
+import { resolveProfile, } from "../browser/config.js";
 import { DEFAULT_NEXUS_BROWSER_COLOR } from "../browser/constants.js";
 import { STATE_DIR_NEXUS } from "../config/config.js";
 import { defaultRuntime } from "../runtime.js";
@@ -27,7 +27,14 @@ const DEFAULT_TOOL_ALLOW = [
     "sessions_send",
     "sessions_spawn",
 ];
-const DEFAULT_TOOL_DENY = ["browser", "canvas", "nodes", "cron", "discord", "gateway"];
+const DEFAULT_TOOL_DENY = [
+    "browser",
+    "canvas",
+    "nodes",
+    "cron",
+    "discord",
+    "gateway",
+];
 export const DEFAULT_SANDBOX_BROWSER_IMAGE = "nexus-sandbox-browser:bookworm-slim";
 export const DEFAULT_SANDBOX_COMMON_IMAGE = "nexus-sandbox-common:bookworm-slim";
 const DEFAULT_SANDBOX_BROWSER_PREFIX = "nexus-sbx-browser-";
@@ -490,7 +497,9 @@ async function ensureSandboxBrowser(params) {
         ? await readDockerPort(containerName, params.cfg.browser.noVncPort)
         : null;
     const existing = BROWSER_BRIDGES.get(params.sessionKey);
-    const existingProfile = existing ? resolveProfile(existing.bridge.state.resolved, "nexus") : null;
+    const existingProfile = existing
+        ? resolveProfile(existing.bridge.state.resolved, "nexus")
+        : null;
     const shouldReuse = existing &&
         existing.containerName === containerName &&
         existingProfile?.cdpPort === mappedCdp;

package/dist/agents/skill-runner.js

@@ -2,15 +2,16 @@ import fs from "node:fs";
 import path from "node:path";
 import { loadConfig } from "../config/config.js";
 import { runCommandWithTimeout } from "../process/exec.js";
-import { MANAGED_SKILLS_DIR, resolveUserPath } from "../utils.js";
-import { DEFAULT_AGENT_WORKSPACE_DIR } from "./workspace.js";
-import { buildWorkspaceSkillStatus } from "./skills-status.js";
-import { getSkillMetadata, hasBinary, loadWorkspaceSkillEntries, } from "./skills.js";
+import { NEXUS_ROOT, resolveUserPath } from "../utils.js";
 import { getSkillExecutionType, getSkillScriptConfig, getSkillToolConfig, } from "./skill-tools.js";
+import { recordSkillUsage } from "./skill-usage.js";
+import { getSkillMetadata, hasBinary, loadWorkspaceSkillEntries, } from "./skills.js";
+import { buildWorkspaceSkillStatus } from "./skills-status.js";
+import { DEFAULT_AGENT_WORKSPACE_DIR } from "./workspace.js";
 function loadSkillContext(name) {
     const config = loadConfig();
     const workspaceDir = resolveUserPath(config.agent?.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR);
-    const managedSkillsDir = MANAGED_SKILLS_DIR;
+    const managedSkillsDir = path.join(NEXUS_ROOT, "skills", "managed");
     const entries = loadWorkspaceSkillEntries(workspaceDir, {
         config,
         managedSkillsDir,
@@ -90,8 +91,18 @@ export async function runSkill(name, args) {
     if (!entry) {
         return { ok: false, error: `Skill not found: ${name}` };
     }
+    const startedAt = Date.now();
+    const record = (ok) => {
+        recordSkillUsage(entry.skill.name, {
+            ts: Date.now(),
+            event: "run",
+            ok,
+            durationMs: Date.now() - startedAt,
+        });
+    };
     const execType = getSkillExecutionType(entry.skill.name);
     if (execType === "prompt") {
+        record(false);
         return {
             ok: false,
             error: "Skill is prompt-only and has no runnable command.",
@@ -100,13 +111,19 @@ export async function runSkill(name, args) {
     if (execType === "tool") {
         const toolConfig = getSkillToolConfig(entry.skill.name);
         if (!toolConfig?.tool) {
+            record(false);
             return { ok: false, error: "Skill tool configuration missing." };
         }
         if (!hasBinary(toolConfig.tool)) {
+            record(false);
             return { ok: false, error: `Missing binary: ${toolConfig.tool}` };
         }
-        const result = await runCommandWithTimeout([toolConfig.tool, ...args], { timeoutMs: 300_000, cwd: entry.skill.baseDir });
+        const result = await runCommandWithTimeout([toolConfig.tool, ...args], {
+            timeoutMs: 300_000,
+            cwd: entry.skill.baseDir,
+        });
         if (result.code !== 0) {
+            record(false);
             return {
                 ok: false,
                 error: result.stderr || result.stdout || "Skill command failed.",
@@ -115,6 +132,7 @@ export async function runSkill(name, args) {
                 code: result.code,
             };
         }
+        record(true);
         return {
             ok: true,
             stdout: result.stdout,
@@ -125,9 +143,11 @@ export async function runSkill(name, args) {
     if (execType === "script") {
         const scriptConfig = getSkillScriptConfig(entry.skill.name);
         if (!scriptConfig) {
+            record(false);
             return { ok: false, error: "Skill script configuration missing." };
         }
         if (!hasBinary(scriptConfig.runner)) {
+            record(false);
             return {
                 ok: false,
                 error: `Missing runner: ${scriptConfig.runner}`,
@@ -135,11 +155,13 @@ export async function runSkill(name, args) {
         }
         const scriptPath = path.join(entry.skill.baseDir, scriptConfig.script);
         if (!fs.existsSync(scriptPath)) {
+            record(false);
             return { ok: false, error: `Script not found: ${scriptConfig.script}` };
         }
         if (scriptConfig.requiredEnv?.length) {
             const missingEnv = scriptConfig.requiredEnv.filter((envName) => !process.env[envName]);
             if (missingEnv.length > 0) {
+                record(false);
                 return {
                     ok: false,
                     error: `Missing env: ${missingEnv.join(", ")}`,
@@ -148,6 +170,7 @@ export async function runSkill(name, args) {
         }
         const result = await runCommandWithTimeout([scriptConfig.runner, scriptPath, ...args], { timeoutMs: 300_000, cwd: entry.skill.baseDir });
         if (result.code !== 0) {
+            record(false);
             return {
                 ok: false,
                 error: result.stderr || result.stdout || "Skill script failed.",
@@ -156,6 +179,7 @@ export async function runSkill(name, args) {
                 code: result.code,
             };
         }
+        record(true);
         return {
             ok: true,
             stdout: result.stdout,
@@ -163,6 +187,7 @@ export async function runSkill(name, args) {
             code: result.code,
         };
     }
+    record(false);
     return { ok: false, error: "Unknown skill execution type." };
 }
 export async function verifySkill(name) {
@@ -175,6 +200,8 @@ export async function verifySkill(name) {
         return { ok: false, error: `Missing requirements: ${missingSummary}` };
     }
     const execType = getSkillExecutionType(entry.skill.name);
+    const metadata = getSkillMetadata(entry);
+    const metaType = metadata?.type;
     if (execType === "prompt") {
         return { ok: true, message: "Prompt-only skill requires no verification." };
     }
@@ -198,6 +225,14 @@ export async function verifySkill(name) {
         }
         return { ok: true, message: "Skill verified successfully." };
     }
+    if (execType === "unknown" && (metaType === "tool" || metaType === "connector")) {
+        const bins = metadata?.requires?.bins ?? metadata?.requires?.anyBins ?? [];
+        const missing = bins.filter((bin) => !hasBinary(bin));
+        if (missing.length > 0) {
+            return { ok: false, error: `Missing binary: ${missing.join(", ")}` };
+        }
+        return { ok: true, message: "Skill appears configured." };
+    }
     if (execType === "script") {
         const scriptConfig = getSkillScriptConfig(entry.skill.name);
         if (!scriptConfig) {

package/dist/agents/skill-usage.js

@@ -1,43 +1,143 @@
+import fs from "node:fs";
+import path from "node:path";
 import { loadConfig } from "../config/config.js";
-import { MANAGED_SKILLS_DIR, resolveUserPath } from "../utils.js";
-import { DEFAULT_AGENT_WORKSPACE_DIR } from "./workspace.js";
-import { buildWorkspaceSkillStatus } from "./skills-status.js";
+import { SKILLS_STATE_DIR, resolveUserPath } from "../utils.js";
 import { loadWorkspaceSkillEntries } from "./skills.js";
+import { buildWorkspaceSkillStatus } from "./skills-status.js";
+import { DEFAULT_AGENT_WORKSPACE_DIR } from "./workspace.js";
 function loadSkillEntries() {
     const config = loadConfig();
     const workspaceDir = resolveUserPath(config.agent?.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR);
-    const managedSkillsDir = MANAGED_SKILLS_DIR;
     const entries = loadWorkspaceSkillEntries(workspaceDir, {
         config,
-        managedSkillsDir,
     });
-    return { config, workspaceDir, managedSkillsDir, entries };
+    return { config, workspaceDir, entries };
+}
+function resolveUsageLogPath(name) {
+    return path.join(SKILLS_STATE_DIR, name, "usage.log");
+}
+function parseUsageEntry(line) {
+    try {
+        const parsed = JSON.parse(line);
+        if (typeof parsed?.ts !== "number")
+            return null;
+        if (parsed.event !== "use" && parsed.event !== "run")
+            return null;
+        if (typeof parsed.ok !== "boolean")
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function readUsageEntries(name, sinceMs) {
+    const logPath = resolveUsageLogPath(name);
+    try {
+        const raw = fs.readFileSync(logPath, "utf-8");
+        const entries = [];
+        for (const line of raw.split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            const entry = parseUsageEntry(line);
+            if (!entry)
+                continue;
+            if (sinceMs && entry.ts < sinceMs)
+                continue;
+            entries.push(entry);
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+function hasUsageEntries(name) {
+    const logPath = resolveUsageLogPath(name);
+    try {
+        const stat = fs.statSync(logPath);
+        return stat.isFile() && stat.size > 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function hasSkillUsage(name) {
+    return hasUsageEntries(name);
+}
+export function readSkillUsageEntries(name, opts) {
+    const entries = readUsageEntries(name, opts?.sinceMs);
+    if (opts?.limit && opts.limit > 0) {
+        return entries.slice(-opts.limit);
+    }
+    return entries;
+}
+export function recordSkillUsage(name, entry) {
+    const logPath = resolveUsageLogPath(name);
+    try {
+        fs.mkdirSync(path.dirname(logPath), { recursive: true });
+        fs.appendFileSync(logPath, `${JSON.stringify(entry)}\n`, "utf-8");
+    }
+    catch {
+        // ignore logging failures
+    }
 }
-export async function getSkillStats(name) {
+export async function getSkillStats(name, opts) {
     const { entries } = loadSkillEntries();
     const entry = entries.find((item) => item.skill.name.toLowerCase() === name.toLowerCase());
     if (!entry)
         return null;
+    const sinceMs = opts?.windowDays && opts.windowDays > 0
+        ? Date.now() - opts.windowDays * 24 * 60 * 60 * 1000
+        : undefined;
+    const entriesUsed = readUsageEntries(entry.skill.name, sinceMs);
+    const runs = entriesUsed.length;
+    const errors = entriesUsed.filter((item) => !item.ok).length;
+    const lastTs = entriesUsed.reduce((max, item) => Math.max(max, item.ts), 0);
+    const durations = entriesUsed
+        .map((item) => item.durationMs)
+        .filter((val) => typeof val === "number" && val >= 0);
+    const avgDurationMs = durations.length > 0
+        ? Math.round(durations.reduce((sum, val) => sum + val, 0) / durations.length)
+        : undefined;
     return {
-        runs: 0,
-        errors: 0,
-        lastUsed: undefined,
-        avgDurationMs: undefined,
+        runs,
+        errors,
+        lastUsed: lastTs ? new Date(lastTs).toISOString() : undefined,
+        avgDurationMs,
     };
 }
-export async function getAggregateStats() {
-    const { config, workspaceDir, managedSkillsDir, entries } = loadSkillEntries();
+export async function getAggregateStats(opts) {
+    const { config, workspaceDir, entries } = loadSkillEntries();
     const status = buildWorkspaceSkillStatus(workspaceDir, {
         config,
-        managedSkillsDir,
         entries,
     });
+    const sinceMs = opts?.windowDays && opts.windowDays > 0
+        ? Date.now() - opts.windowDays * 24 * 60 * 60 * 1000
+        : undefined;
+    const usageCounts = [];
+    let totalRuns = 0;
+    for (const entry of entries) {
+        const skillRuns = readUsageEntries(entry.skill.name, sinceMs).length;
+        if (skillRuns > 0) {
+            usageCounts.push({ name: entry.skill.name, runs: skillRuns });
+        }
+        totalRuns += skillRuns;
+    }
+    usageCounts.sort((a, b) => b.runs - a.runs);
+    const mostUsed = usageCounts[0];
+    const limit = typeof opts?.limit === "number" && opts.limit > 0 ? opts.limit : 5;
+    const topUsed = usageCounts.slice(0, limit);
     return {
-        totalRuns: 0,
+        totalRuns,
         activeSkills: entries.length,
-        mostUsed: undefined,
+        mostUsed: mostUsed
+            ? { name: mostUsed.name, runs: mostUsed.runs }
+            : undefined,
+        topUsed: topUsed.map((item) => ({ name: item.name, runs: item.runs })),
         readyButUnused: status.skills
-            .filter((skill) => skill.eligible)
+            .filter((skill) => skill.eligible && !hasUsageEntries(skill.name))
             .map((skill) => skill.name),
     };
 }

package/dist/agents/skills-status.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { CONFIG_DIR } from "../utils.js";
+import { NEXUS_ROOT } from "../utils.js";
 import { getSkillMetadata, hasBinary, isBundledSkillAllowed, isConfigPathTruthy, loadWorkspaceSkillEntries, resolveBundledAllowlist, resolveConfigPath, resolveSkillConfig, resolveSkillsInstallPreferences, } from "./skills.js";
 function resolveSkillKey(entry) {
     return getSkillMetadata(entry)?.skillKey ?? entry.skill.name;
@@ -92,7 +92,8 @@ function buildSkillStatus(entry, config, prefs) {
             continue;
         if (skillConfig?.env?.[envName])
             continue;
-        if (skillConfig?.apiKey && getSkillMetadata(entry)?.primaryEnv === envName) {
+        if (skillConfig?.apiKey &&
+            getSkillMetadata(entry)?.primaryEnv === envName) {
             continue;
         }
         missingEnv.push(envName);
@@ -146,7 +147,7 @@ function buildSkillStatus(entry, config, prefs) {
     };
 }
 export function buildWorkspaceSkillStatus(workspaceDir, opts) {
-    const managedSkillsDir = opts?.managedSkillsDir ?? path.join(CONFIG_DIR, "skills");
+    const managedSkillsDir = opts?.managedSkillsDir ?? path.join(NEXUS_ROOT, "skills", "managed");
     const skillEntries = opts?.entries ?? loadWorkspaceSkillEntries(workspaceDir, opts);
     const prefs = resolveSkillsInstallPreferences(opts?.config);
     return {