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

package/dist/infra/usage-upload.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import readline from "node:readline";
 import { resolveStateDir } from "../config/paths.js";
 import { resolveEventLogDir } from "./event-log.js";
+import { fetchUsageTrackingSettings } from "./usage-settings.js";
 const UPLOAD_URL_ENV = "NEXUS_USAGE_UPLOAD_URL";
 const UPLOAD_TOKEN_ENV = "NEXUS_USAGE_UPLOAD_TOKEN";
 const OUTBOX_DIR_ENV = "NEXUS_USAGE_OUTBOX_DIR";
@@ -39,9 +40,34 @@ function writeJSON(pathname, data) {
     fs.mkdirSync(path.dirname(pathname), { recursive: true });
     fs.writeFileSync(pathname, JSON.stringify(data, null, 2), "utf-8");
 }
+function updateTrackingState(state, settings) {
+    if (!settings)
+        return;
+    state.opted_out = settings.canOptOut && settings.optOut;
+    state.settings_checked_at = Date.now();
+    writeJSON(stateFilePath(), state);
+}
+function isTrackingDisabled(state, settings) {
+    if (settings)
+        return settings.canOptOut && settings.optOut;
+    return Boolean(state.opted_out);
+}
+function clearUsageOutbox() {
+    const outboxDir = resolveOutboxDir();
+    if (!fs.existsSync(outboxDir))
+        return 0;
+    const files = fs
+        .readdirSync(outboxDir)
+        .filter((name) => name.endsWith(".json"))
+        .map((name) => path.join(outboxDir, name));
+    for (const file of files) {
+        fs.unlinkSync(file);
+    }
+    return files.length;
+}
 function getOrCreateUsageState() {
     const existing = readJSON(stateFilePath());
-    if (existing && existing.anon_id && existing.anon_salt) {
+    if (existing?.anon_id && existing.anon_salt) {
         return existing;
     }
     const anonId = crypto.randomUUID();
@@ -260,6 +286,17 @@ export async function flushUsageOutbox() {
 }
 export async function runUsageUpload(opts = {}) {
     const limit = opts.limit && opts.limit > 0 ? opts.limit : 1000;
+    const state = getOrCreateUsageState();
+    const settings = await fetchUsageTrackingSettings();
+    const resolvedSettings = settings?.ok ? settings : null;
+    updateTrackingState(state, resolvedSettings);
+    if (isTrackingDisabled(state, resolvedSettings)) {
+        const cleared = clearUsageOutbox();
+        return {
+            status: "disabled",
+            cleared,
+        };
+    }
     if (!opts.onlyFlush) {
         const { batch, nextState, count } = await buildUsageUploadBatch(limit);
         if (opts.dryRun) {

package/dist/infra/voicewake.js

@@ -2,10 +2,10 @@ import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { resolveConfigDir } from "../utils.js";
+import { resolveStateDir } from "../config/paths.js";
 const DEFAULT_TRIGGERS = ["nexus", "claude", "computer"];
 function defaultBaseDir() {
-    return resolveConfigDir(process.env, os.homedir);
+    return resolveStateDir(process.env, os.homedir);
 }
 function resolvePath(baseDir) {
     const root = baseDir ?? defaultBaseDir();

package/dist/media/image-ops.js

@@ -7,7 +7,9 @@ function isBun() {
 }
 function prefersSips() {
     return (process.env.NEXUS_IMAGE_BACKEND === "sips" ||
-        (process.env.NEXUS_IMAGE_BACKEND !== "sharp" && isBun() && process.platform === "darwin"));
+        (process.env.NEXUS_IMAGE_BACKEND !== "sharp" &&
+            isBun() &&
+            process.platform === "darwin"));
 }
 async function loadSharp() {
     const mod = (await import("sharp"));

package/dist/memory/index.js

@@ -1,382 +1,3 @@
-import fs from "node:fs/promises";
-import { createRequire } from "node:module";
-import path from "node:path";
-import chokidar from "chokidar";
-import { resolveAgentDir, resolveAgentWorkspaceDir } from "../agents/agent-scope.js";
-import { resolveMemorySearchConfig } from "../agents/memory-search.js";
-import { resolveUserPath, truncateUtf16Safe } from "../utils.js";
-import { createEmbeddingProvider, } from "./embeddings.js";
-import { buildFileEntry, chunkMarkdown, cosineSimilarity, ensureDir, hashText, isMemoryPath, listMemoryFiles, normalizeRelPath, parseEmbedding, } from "./internal.js";
-const require = createRequire(import.meta.url);
-function requireNodeSqlite() {
-    const onWarning = (warning) => {
-        if (warning.name === "ExperimentalWarning" &&
-            warning.message?.includes("SQLite is an experimental feature")) {
-            return;
-        }
-        process.stderr.write(`${warning.stack ?? warning.toString()}\n`);
-    };
-    process.on("warning", onWarning);
-    try {
-        return require("node:sqlite");
-    }
-    finally {
-        process.off("warning", onWarning);
-    }
-}
-const META_KEY = "memory_index_meta_v1";
-const SNIPPET_MAX_CHARS = 700;
-const INDEX_CACHE = new Map();
-export class MemoryIndexManager {
-    cacheKey;
-    cfg;
-    agentId;
-    workspaceDir;
-    settings;
-    provider;
-    requestedProvider;
-    fallbackReason;
-    db;
-    watcher = null;
-    watchTimer = null;
-    intervalTimer = null;
-    closed = false;
-    dirty = false;
-    sessionWarm = new Set();
-    syncing = null;
-    static async get(params) {
-        const { cfg, agentId } = params;
-        const settings = resolveMemorySearchConfig(cfg, agentId);
-        if (!settings)
-            return null;
-        const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);
-        const key = `${agentId}:${workspaceDir}:${JSON.stringify(settings)}`;
-        const existing = INDEX_CACHE.get(key);
-        if (existing)
-            return existing;
-        const providerResult = await createEmbeddingProvider({
-            config: cfg,
-            agentDir: resolveAgentDir(cfg, agentId),
-            provider: settings.provider,
-            remote: settings.remote,
-            model: settings.model,
-            fallback: settings.fallback,
-            local: settings.local,
-        });
-        const manager = new MemoryIndexManager({
-            cacheKey: key,
-            cfg,
-            agentId,
-            workspaceDir,
-            settings,
-            providerResult,
-        });
-        INDEX_CACHE.set(key, manager);
-        return manager;
-    }
-    constructor(params) {
-        this.cacheKey = params.cacheKey;
-        this.cfg = params.cfg;
-        this.agentId = params.agentId;
-        this.workspaceDir = params.workspaceDir;
-        this.settings = params.settings;
-        this.provider = params.providerResult.provider;
-        this.requestedProvider = params.providerResult.requestedProvider;
-        this.fallbackReason = params.providerResult.fallbackReason;
-        this.db = this.openDatabase();
-        this.ensureSchema();
-        this.ensureWatcher();
-        this.ensureIntervalSync();
-        this.dirty = true;
-    }
-    async warmSession(sessionKey) {
-        if (!this.settings.sync.onSessionStart)
-            return;
-        const key = sessionKey?.trim() || "";
-        if (key && this.sessionWarm.has(key))
-            return;
-        await this.sync({ reason: "session-start" });
-        if (key)
-            this.sessionWarm.add(key);
-    }
-    async search(query, opts) {
-        await this.warmSession(opts?.sessionKey);
-        if (this.settings.sync.onSearch && this.dirty) {
-            await this.sync({ reason: "search" });
-        }
-        const cleaned = query.trim();
-        if (!cleaned)
-            return [];
-        const queryVec = await this.provider.embedQuery(cleaned);
-        if (queryVec.length === 0)
-            return [];
-        const candidates = this.listChunks();
-        const scored = candidates
-            .map((chunk) => ({
-            chunk,
-            score: cosineSimilarity(queryVec, chunk.embedding),
-        }))
-            .filter((entry) => Number.isFinite(entry.score));
-        const minScore = opts?.minScore ?? this.settings.query.minScore;
-        const maxResults = opts?.maxResults ?? this.settings.query.maxResults;
-        return scored
-            .filter((entry) => entry.score >= minScore)
-            .sort((a, b) => b.score - a.score)
-            .slice(0, maxResults)
-            .map((entry) => ({
-            path: entry.chunk.path,
-            startLine: entry.chunk.startLine,
-            endLine: entry.chunk.endLine,
-            score: entry.score,
-            snippet: truncateUtf16Safe(entry.chunk.text, SNIPPET_MAX_CHARS),
-        }));
-    }
-    async readFile(params) {
-        const relPath = normalizeRelPath(params.relPath);
-        if (!relPath)
-            return { text: "", error: "Invalid path" };
-        if (!isMemoryPath(relPath)) {
-            return { text: "", error: "Path must be MEMORY.md or memory/*.md" };
-        }
-        const absPath = path.join(this.workspaceDir, relPath);
-        try {
-            const content = await fs.readFile(absPath, "utf-8");
-            const lines = content.split("\n");
-            const start = Math.max(1, params.from ?? 1);
-            const count = Math.max(1, params.lines ?? lines.length);
-            const slice = lines.slice(start - 1, start - 1 + count);
-            return { text: slice.join("\n"), path: relPath };
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            return { text: "", error: message };
-        }
-    }
-    status() {
-        const files = this.db.prepare(`SELECT COUNT(*) as c FROM files`).get();
-        const chunks = this.db.prepare(`SELECT COUNT(*) as c FROM chunks`).get();
-        return {
-            files: files?.c ?? 0,
-            chunks: chunks?.c ?? 0,
-            dirty: this.dirty,
-            workspaceDir: this.workspaceDir,
-            dbPath: this.settings.store.path,
-            provider: this.provider.id,
-            model: this.provider.model,
-            requestedProvider: this.requestedProvider,
-            fallback: this.fallbackReason ? { from: "local", reason: this.fallbackReason } : undefined,
-        };
-    }
-    async close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        if (this.watchTimer) {
-            clearTimeout(this.watchTimer);
-            this.watchTimer = null;
-        }
-        if (this.intervalTimer) {
-            clearInterval(this.intervalTimer);
-            this.intervalTimer = null;
-        }
-        if (this.watcher) {
-            await this.watcher.close();
-            this.watcher = null;
-        }
-        this.db.close();
-        INDEX_CACHE.delete(this.cacheKey);
-    }
-    openDatabase() {
-        const dbPath = resolveUserPath(this.settings.store.path);
-        const dir = path.dirname(dbPath);
-        ensureDir(dir);
-        const { DatabaseSync } = requireNodeSqlite();
-        return new DatabaseSync(dbPath);
-    }
-    ensureSchema() {
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS meta (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-    `);
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS files (
-        path TEXT PRIMARY KEY,
-        hash TEXT NOT NULL,
-        mtime INTEGER NOT NULL,
-        size INTEGER NOT NULL
-      );
-    `);
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS chunks (
-        id TEXT PRIMARY KEY,
-        path TEXT NOT NULL,
-        start_line INTEGER NOT NULL,
-        end_line INTEGER NOT NULL,
-        hash TEXT NOT NULL,
-        model TEXT NOT NULL,
-        text TEXT NOT NULL,
-        embedding TEXT NOT NULL,
-        updated_at INTEGER NOT NULL
-      );
-    `);
-        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_path ON chunks(path);`);
-    }
-    ensureWatcher() {
-        if (!this.settings.sync.watch || this.watcher)
-            return;
-        const watchPaths = [
-            path.join(this.workspaceDir, "MEMORY.md"),
-            path.join(this.workspaceDir, "memory"),
-        ];
-        this.watcher = chokidar.watch(watchPaths, {
-            ignoreInitial: true,
-            awaitWriteFinish: {
-                stabilityThreshold: this.settings.sync.watchDebounceMs,
-                pollInterval: 100,
-            },
-        });
-        const markDirty = () => {
-            this.dirty = true;
-            this.scheduleWatchSync();
-        };
-        this.watcher.on("add", markDirty);
-        this.watcher.on("change", markDirty);
-        this.watcher.on("unlink", markDirty);
-    }
-    ensureIntervalSync() {
-        const minutes = this.settings.sync.intervalMinutes;
-        if (!minutes || minutes <= 0 || this.intervalTimer)
-            return;
-        const ms = minutes * 60 * 1000;
-        this.intervalTimer = setInterval(() => {
-            void this.sync({ reason: "interval" });
-        }, ms);
-    }
-    scheduleWatchSync() {
-        if (!this.settings.sync.watch)
-            return;
-        if (this.watchTimer)
-            clearTimeout(this.watchTimer);
-        this.watchTimer = setTimeout(() => {
-            this.watchTimer = null;
-            void this.sync({ reason: "watch" });
-        }, this.settings.sync.watchDebounceMs);
-    }
-    listChunks() {
-        const rows = this.db
-            .prepare(`SELECT path, start_line, end_line, text, embedding FROM chunks WHERE model = ?`)
-            .all(this.provider.model);
-        return rows.map((row) => ({
-            path: row.path,
-            startLine: row.start_line,
-            endLine: row.end_line,
-            text: row.text,
-            embedding: parseEmbedding(row.embedding),
-        }));
-    }
-    async sync(params) {
-        if (this.syncing)
-            return this.syncing;
-        this.syncing = this.runSync(params).finally(() => {
-            this.syncing = null;
-        });
-        return this.syncing;
-    }
-    async runSync(params) {
-        const meta = this.readMeta();
-        const needsFullReindex = params?.force ||
-            !meta ||
-            meta.model !== this.provider.model ||
-            meta.provider !== this.provider.id ||
-            meta.chunkTokens !== this.settings.chunking.tokens ||
-            meta.chunkOverlap !== this.settings.chunking.overlap;
-        if (needsFullReindex) {
-            this.resetIndex();
-        }
-        const files = await listMemoryFiles(this.workspaceDir);
-        const fileEntries = await Promise.all(files.map(async (file) => buildFileEntry(file, this.workspaceDir)));
-        const activePaths = new Set(fileEntries.map((entry) => entry.path));
-        for (const entry of fileEntries) {
-            const record = this.db.prepare(`SELECT hash FROM files WHERE path = ?`).get(entry.path);
-            if (!needsFullReindex && record?.hash === entry.hash) {
-                continue;
-            }
-            await this.indexFile(entry);
-        }
-        const staleRows = this.db.prepare(`SELECT path FROM files`).all();
-        for (const stale of staleRows) {
-            if (activePaths.has(stale.path))
-                continue;
-            this.db.prepare(`DELETE FROM files WHERE path = ?`).run(stale.path);
-            this.db.prepare(`DELETE FROM chunks WHERE path = ?`).run(stale.path);
-        }
-        this.writeMeta({
-            model: this.provider.model,
-            provider: this.provider.id,
-            chunkTokens: this.settings.chunking.tokens,
-            chunkOverlap: this.settings.chunking.overlap,
-        });
-        this.dirty = false;
-    }
-    resetIndex() {
-        this.db.exec(`DELETE FROM files`);
-        this.db.exec(`DELETE FROM chunks`);
-    }
-    readMeta() {
-        const row = this.db.prepare(`SELECT value FROM meta WHERE key = ?`).get(META_KEY);
-        if (!row?.value)
-            return null;
-        try {
-            return JSON.parse(row.value);
-        }
-        catch {
-            return null;
-        }
-    }
-    writeMeta(meta) {
-        const value = JSON.stringify(meta);
-        this.db
-            .prepare(`INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`)
-            .run(META_KEY, value);
-    }
-    async indexFile(entry) {
-        const content = await fs.readFile(entry.absPath, "utf-8");
-        const chunks = chunkMarkdown(content, this.settings.chunking);
-        const embeddings = await this.provider.embedBatch(chunks.map((chunk) => chunk.text));
-        const now = Date.now();
-        this.db.prepare(`DELETE FROM chunks WHERE path = ?`).run(entry.path);
-        for (let i = 0; i < chunks.length; i += 1) {
-            const chunk = chunks[i];
-            const embedding = embeddings[i] ?? [];
-            if (!chunk)
-                continue;
-            const id = hashText(`${entry.path}:${chunk.startLine}:${chunk.endLine}:${chunk.hash}:${this.provider.model}`);
-            this.db
-                .prepare(`INSERT INTO chunks (id, path, start_line, end_line, hash, model, text, embedding, updated_at)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-           ON CONFLICT(id) DO UPDATE SET
-             hash=excluded.hash,
-             model=excluded.model,
-             text=excluded.text,
-             embedding=excluded.embedding,
-             updated_at=excluded.updated_at`)
-                .run(id, entry.path, chunk.startLine, chunk.endLine, chunk.hash, this.provider.model, chunk.text, JSON.stringify(embedding), now);
-        }
-        this.db
-            .prepare(`INSERT INTO files (path, hash, mtime, size) VALUES (?, ?, ?, ?)
-         ON CONFLICT(path) DO UPDATE SET hash=excluded.hash, mtime=excluded.mtime, size=excluded.size`)
-            .run(entry.path, entry.hash, entry.mtimeMs, entry.size);
-    }
-}
-export async function getMemorySearchManager(params) {
-    try {
-        const manager = await MemoryIndexManager.get(params);
-        return { manager };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { manager: null, error: message };
-    }
+export async function getMemorySearchManager() {
+    return { manager: null, error: "sqlite unavailable" };
 }

package/dist/pairing/pairing-store.js

@@ -192,3 +192,27 @@ export async function approveProviderPairingCode(params) {
     });
     return { id: entry.id, entry };
 }
+export const readChannelAllowFromStore = readProviderAllowFromStore;
+export async function addChannelAllowFromStoreEntry(params) {
+    return addProviderAllowFromStoreEntry({
+        provider: params.channel,
+        entry: params.entry,
+        env: params.env,
+    });
+}
+export const listChannelPairingRequests = listProviderPairingRequests;
+export async function upsertChannelPairingRequest(params) {
+    return upsertProviderPairingRequest({
+        provider: params.channel,
+        id: params.id,
+        meta: params.meta,
+        env: params.env,
+    });
+}
+export async function approveChannelPairingCode(params) {
+    return approveProviderPairingCode({
+        provider: params.channel,
+        code: params.code,
+        env: params.env,
+    });
+}

package/dist/providers/github-copilot-auth.js

@@ -1,5 +1,5 @@
 import { intro, note, outro, spinner } from "@clack/prompts";
-import { ensureAuthProfileStore, upsertAuthProfile } from "../agents/auth-profiles.js";
+import { ensureAuthProfileStore, upsertAuthProfile, } from "../agents/auth-profiles.js";
 import { updateConfig } from "../commands/models/shared.js";
 import { applyAuthProfileConfig } from "../commands/onboard-auth.js";
 import { CONFIG_PATH_NEXUS } from "../config/config.js";

package/dist/routing/resolve-route.js

@@ -24,7 +24,7 @@ export function buildAgentSessionKey(params) {
     return buildAgentPeerSessionKey({
         agentId: params.agentId,
         mainKey: DEFAULT_MAIN_KEY,
-        provider,
+        channel: provider,
         peerKind: peer?.kind ?? "dm",
         peerId: peer ? normalizeId(peer.id) || "unknown" : null,
     });
@@ -52,11 +52,11 @@ function pickFirstExistingAgentId(cfg, agentId) {
         return normalized;
     return normalizeAgentId(resolveDefaultAgentId(cfg));
 }
-function matchesProvider(match, provider) {
-    const key = normalizeToken(match?.provider);
+function matchesChannel(match, channel) {
+    const key = normalizeToken(match?.channel);
     if (!key)
         return false;
-    return key === provider;
+    return key === channel;
 }
 function matchesPeer(match, peer) {
     const m = match?.peer;
@@ -91,7 +91,7 @@ export function resolveAgentRoute(input) {
     const bindings = listBindings(input.cfg).filter((binding) => {
         if (!binding || typeof binding !== "object")
             return false;
-        if (!matchesProvider(binding.match, provider))
+        if (!matchesChannel(binding.match, provider))
             return false;
         return matchesAccountId(binding.match?.accountId, accountId);
     });
@@ -139,6 +139,6 @@ export function resolveAgentRoute(input) {
         !b.match?.guildId &&
         !b.match?.teamId);
     if (anyAccountMatch)
-        return choose(anyAccountMatch.agentId, "binding.provider");
+        return choose(anyAccountMatch.agentId, "binding.channel");
     return choose(resolveDefaultAgentId(input.cfg), "default");
 }

package/dist/routing/session-key.js

@@ -57,7 +57,9 @@ export function buildAgentPeerSessionKey(params) {
             mainKey: params.mainKey,
         });
     }
-    const provider = (params.provider ?? "").trim().toLowerCase() || "unknown";
+    const provider = (params.channel ?? params.provider ?? "")
+        .trim()
+        .toLowerCase() || "unknown";
     const peerId = (params.peerId ?? "").trim() || "unknown";
     return `agent:${normalizeAgentId(params.agentId)}:${provider}:${peerKind}:${peerId}`;
 }

package/dist/sessions/send-policy.js

@@ -10,7 +10,7 @@ function normalizeMatchValue(raw) {
     const value = raw?.trim().toLowerCase();
     return value ? value : undefined;
 }
-function deriveProviderFromKey(key) {
+function deriveChannelFromKey(key) {
     if (!key)
         return undefined;
     const parts = key.split(":").filter(Boolean);
@@ -35,10 +35,10 @@ export function resolveSendPolicy(params) {
     const policy = params.cfg.session?.sendPolicy;
     if (!policy)
         return "allow";
-    const provider = normalizeMatchValue(params.provider) ??
+    const channel = normalizeMatchValue(params.provider) ??
         normalizeMatchValue(params.entry?.provider) ??
         normalizeMatchValue(params.entry?.lastProvider) ??
-        deriveProviderFromKey(params.sessionKey);
+        deriveChannelFromKey(params.sessionKey);
     const chatType = normalizeMatchValue(params.chatType ?? params.entry?.chatType) ??
         normalizeMatchValue(deriveChatTypeFromKey(params.sessionKey));
     const sessionKey = params.sessionKey ?? "";
@@ -48,10 +48,10 @@ export function resolveSendPolicy(params) {
             continue;
         const action = normalizeSendPolicy(rule.action) ?? "allow";
         const match = rule.match ?? {};
-        const matchProvider = normalizeMatchValue(match.provider);
+        const matchChannel = normalizeMatchValue(match.channel);
         const matchChatType = normalizeMatchValue(match.chatType);
         const matchPrefix = normalizeMatchValue(match.keyPrefix);
-        if (matchProvider && matchProvider !== provider)
+        if (matchChannel && matchChannel !== channel)
             continue;
         if (matchChatType && matchChatType !== chatType)
             continue;

package/dist/slack/monitor.js

@@ -27,6 +27,9 @@ function normalizeSlackSlug(raw) {
     const cleaned = dashed.replace(/[^a-z0-9#@._+-]+/g, "-");
     return cleaned.replace(/-{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "");
 }
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function normalizeSlackSlashCommandName(raw) {
     const trimmed = raw?.trim().toLowerCase() ?? "";
     if (!trimmed)
@@ -34,6 +37,24 @@ function normalizeSlackSlashCommandName(raw) {
     const stripped = trimmed.startsWith("/") ? trimmed.slice(1) : trimmed;
     return normalizeSlackSlug(stripped);
 }
+export function buildSlackSlashCommandMatcher(rawName) {
+    const normalized = normalizeSlackSlashCommandName(rawName);
+    const name = normalized || "nexus";
+    return new RegExp(`^/?${escapeRegExp(name)}$`, "i");
+}
+export function resolveSlackThreadTs(params) {
+    if (params.incomingThreadTs)
+        return params.incomingThreadTs;
+    if (params.replyToMode === "off")
+        return undefined;
+    if (!params.messageTs)
+        return undefined;
+    if (params.replyToMode === "all")
+        return params.messageTs;
+    if (!params.hasReplied)
+        return params.messageTs;
+    return undefined;
+}
 function normalizeAllowList(list) {
     return (list ?? []).map((entry) => String(entry).trim()).filter(Boolean);
 }
@@ -62,7 +83,7 @@ function allowListMatches(params) {
 function resolveSlackSlashCommandConfig(raw) {
     const rawName = raw?.name?.trim() || "nexus";
     const normalizedName = normalizeSlackSlashCommandName(rawName);
-    const name = normalizedName || "nexus";
+    const _name = normalizedName || "nexus";
     return {
         enabled: raw?.enabled === true,
         name: raw?.name?.trim() || "clawd",

package/dist/telegram/reaction-level.js

@@ -5,7 +5,8 @@ export function resolveTelegramReactionLevel(params) {
     const channelConfig = "channels" in params.cfg
         ? params.cfg.channels?.telegram
         : undefined;
-    const telegramCfg = channelConfig ?? params.cfg.telegram;
+    const telegramCfg = channelConfig ??
+        params.cfg.telegram;
     const level = (telegramCfg?.reactionLevel ?? "ack");
     switch (level) {
         case "off":

package/dist/utils.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { resolveStateDir } from "./config/paths.js";
 import { logVerbose, shouldLogVerbose } from "./globals.js";
 export async function ensureDir(dir) {
     await fs.promises.mkdir(dir, { recursive: true });
@@ -147,7 +148,7 @@ export function resolveNexusRoot(env = process.env, homedir = os.homedir) {
         return resolveUserPath(override);
     return path.join(homedir(), "nexus");
 }
-// Nexus root directory containing home/, skills/, state/
+// Nexus root directory containing home/ and state/
 export const NEXUS_ROOT = resolveNexusRoot();
-// Managed skills directory (for NexusHub installs, etc.)
-export const MANAGED_SKILLS_DIR = path.join(NEXUS_ROOT, "skills");
+// Managed skills directory lives under state/
+export const MANAGED_SKILLS_DIR = path.join(resolveStateDir(), "skills");