@intent-systems/nexus 2026.1.5-3

package/dist/auto-reply/reply/queue.js

@@ -0,0 +1,399 @@
+import { parseDurationMs } from "../../cli/parse-duration.js";
+import { defaultRuntime } from "../../runtime.js";
+const DEFAULT_QUEUE_DEBOUNCE_MS = 1000;
+const DEFAULT_QUEUE_CAP = 20;
+const DEFAULT_QUEUE_DROP = "summarize";
+const FOLLOWUP_QUEUES = new Map();
+function normalizeQueueMode(raw) {
+    if (!raw)
+        return undefined;
+    const cleaned = raw.trim().toLowerCase();
+    if (cleaned === "queue" || cleaned === "queued")
+        return "steer";
+    if (cleaned === "interrupt" ||
+        cleaned === "interrupts" ||
+        cleaned === "abort")
+        return "interrupt";
+    if (cleaned === "steer" || cleaned === "steering")
+        return "steer";
+    if (cleaned === "followup" ||
+        cleaned === "follow-ups" ||
+        cleaned === "followups")
+        return "followup";
+    if (cleaned === "collect" || cleaned === "coalesce")
+        return "collect";
+    if (cleaned === "steer+backlog" ||
+        cleaned === "steer-backlog" ||
+        cleaned === "steer_backlog")
+        return "steer-backlog";
+    return undefined;
+}
+function normalizeQueueDropPolicy(raw) {
+    if (!raw)
+        return undefined;
+    const cleaned = raw.trim().toLowerCase();
+    if (cleaned === "old" || cleaned === "oldest")
+        return "old";
+    if (cleaned === "new" || cleaned === "newest")
+        return "new";
+    if (cleaned === "summarize" || cleaned === "summary")
+        return "summarize";
+    return undefined;
+}
+function parseQueueDebounce(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = parseDurationMs(raw.trim(), { defaultUnit: "ms" });
+        if (!parsed || parsed < 0)
+            return undefined;
+        return Math.round(parsed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseQueueCap(raw) {
+    if (!raw)
+        return undefined;
+    const num = Number(raw);
+    if (!Number.isFinite(num))
+        return undefined;
+    const cap = Math.floor(num);
+    if (cap < 1)
+        return undefined;
+    return cap;
+}
+function parseQueueDirectiveArgs(raw) {
+    let i = 0;
+    const len = raw.length;
+    while (i < len && /\s/.test(raw[i]))
+        i += 1;
+    if (raw[i] === ":") {
+        i += 1;
+        while (i < len && /\s/.test(raw[i]))
+            i += 1;
+    }
+    let consumed = i;
+    let queueMode;
+    let queueReset = false;
+    let rawMode;
+    let debounceMs;
+    let cap;
+    let dropPolicy;
+    let rawDebounce;
+    let rawCap;
+    let rawDrop;
+    let hasOptions = false;
+    const takeToken = () => {
+        if (i >= len)
+            return null;
+        const start = i;
+        while (i < len && !/\s/.test(raw[i]))
+            i += 1;
+        if (start === i)
+            return null;
+        const token = raw.slice(start, i);
+        while (i < len && /\s/.test(raw[i]))
+            i += 1;
+        return token;
+    };
+    while (i < len) {
+        const token = takeToken();
+        if (!token)
+            break;
+        const lowered = token.trim().toLowerCase();
+        if (lowered === "default" || lowered === "reset" || lowered === "clear") {
+            queueReset = true;
+            consumed = i;
+            break;
+        }
+        if (lowered.startsWith("debounce:") || lowered.startsWith("debounce=")) {
+            rawDebounce = token.split(/[:=]/)[1] ?? "";
+            debounceMs = parseQueueDebounce(rawDebounce);
+            hasOptions = true;
+            consumed = i;
+            continue;
+        }
+        if (lowered.startsWith("cap:") || lowered.startsWith("cap=")) {
+            rawCap = token.split(/[:=]/)[1] ?? "";
+            cap = parseQueueCap(rawCap);
+            hasOptions = true;
+            consumed = i;
+            continue;
+        }
+        if (lowered.startsWith("drop:") || lowered.startsWith("drop=")) {
+            rawDrop = token.split(/[:=]/)[1] ?? "";
+            dropPolicy = normalizeQueueDropPolicy(rawDrop);
+            hasOptions = true;
+            consumed = i;
+            continue;
+        }
+        const mode = normalizeQueueMode(token);
+        if (mode) {
+            queueMode = mode;
+            rawMode = token;
+            consumed = i;
+            continue;
+        }
+        // Stop at first unrecognized token.
+        break;
+    }
+    return {
+        consumed,
+        queueMode,
+        queueReset,
+        rawMode,
+        debounceMs,
+        cap,
+        dropPolicy,
+        rawDebounce,
+        rawCap,
+        rawDrop,
+        hasOptions,
+    };
+}
+export function extractQueueDirective(body) {
+    if (!body)
+        return {
+            cleaned: "",
+            hasDirective: false,
+            queueReset: false,
+            hasOptions: false,
+        };
+    const re = /(?:^|\s)\/queue(?=$|\s|:)/i;
+    const match = re.exec(body);
+    if (!match) {
+        return {
+            cleaned: body.trim(),
+            hasDirective: false,
+            queueReset: false,
+            hasOptions: false,
+        };
+    }
+    const start = match.index + match[0].indexOf("/queue");
+    const argsStart = start + "/queue".length;
+    const args = body.slice(argsStart);
+    const parsed = parseQueueDirectiveArgs(args);
+    const cleanedRaw = body.slice(0, start) + body.slice(argsStart + parsed.consumed);
+    const cleaned = cleanedRaw.replace(/\s+/g, " ").trim();
+    return {
+        cleaned,
+        queueMode: parsed.queueMode,
+        queueReset: parsed.queueReset,
+        rawMode: parsed.rawMode,
+        debounceMs: parsed.debounceMs,
+        cap: parsed.cap,
+        dropPolicy: parsed.dropPolicy,
+        rawDebounce: parsed.rawDebounce,
+        rawCap: parsed.rawCap,
+        rawDrop: parsed.rawDrop,
+        hasDirective: true,
+        hasOptions: parsed.hasOptions,
+    };
+}
+function elideText(text, limit = 140) {
+    if (text.length <= limit)
+        return text;
+    return `${text.slice(0, Math.max(0, limit - 1)).trimEnd()}…`;
+}
+function buildQueueSummaryLine(run) {
+    const base = run.summaryLine?.trim() || run.prompt.trim();
+    const cleaned = base.replace(/\s+/g, " ").trim();
+    return elideText(cleaned, 160);
+}
+function getFollowupQueue(key, settings) {
+    const existing = FOLLOWUP_QUEUES.get(key);
+    if (existing) {
+        existing.mode = settings.mode;
+        existing.debounceMs =
+            typeof settings.debounceMs === "number"
+                ? Math.max(0, settings.debounceMs)
+                : existing.debounceMs;
+        existing.cap =
+            typeof settings.cap === "number" && settings.cap > 0
+                ? Math.floor(settings.cap)
+                : existing.cap;
+        existing.dropPolicy = settings.dropPolicy ?? existing.dropPolicy;
+        return existing;
+    }
+    const created = {
+        items: [],
+        draining: false,
+        lastEnqueuedAt: 0,
+        mode: settings.mode,
+        debounceMs: typeof settings.debounceMs === "number"
+            ? Math.max(0, settings.debounceMs)
+            : DEFAULT_QUEUE_DEBOUNCE_MS,
+        cap: typeof settings.cap === "number" && settings.cap > 0
+            ? Math.floor(settings.cap)
+            : DEFAULT_QUEUE_CAP,
+        dropPolicy: settings.dropPolicy ?? DEFAULT_QUEUE_DROP,
+        droppedCount: 0,
+        summaryLines: [],
+    };
+    FOLLOWUP_QUEUES.set(key, created);
+    return created;
+}
+export function enqueueFollowupRun(key, run, settings) {
+    const queue = getFollowupQueue(key, settings);
+    queue.lastEnqueuedAt = Date.now();
+    queue.lastRun = run.run;
+    const cap = queue.cap;
+    if (cap > 0 && queue.items.length >= cap) {
+        if (queue.dropPolicy === "new") {
+            return false;
+        }
+        const dropCount = queue.items.length - cap + 1;
+        const dropped = queue.items.splice(0, dropCount);
+        if (queue.dropPolicy === "summarize") {
+            for (const item of dropped) {
+                queue.droppedCount += 1;
+                queue.summaryLines.push(buildQueueSummaryLine(item));
+            }
+            while (queue.summaryLines.length > cap)
+                queue.summaryLines.shift();
+        }
+    }
+    queue.items.push(run);
+    return true;
+}
+async function waitForQueueDebounce(queue) {
+    const debounceMs = Math.max(0, queue.debounceMs);
+    if (debounceMs <= 0)
+        return;
+    while (true) {
+        const since = Date.now() - queue.lastEnqueuedAt;
+        if (since >= debounceMs)
+            return;
+        await new Promise((resolve) => setTimeout(resolve, debounceMs - since));
+    }
+}
+function buildSummaryPrompt(queue) {
+    if (queue.dropPolicy !== "summarize" || queue.droppedCount <= 0) {
+        return undefined;
+    }
+    const lines = [
+        `[Queue overflow] Dropped ${queue.droppedCount} message${queue.droppedCount === 1 ? "" : "s"} due to cap.`,
+    ];
+    if (queue.summaryLines.length > 0) {
+        lines.push("Summary:");
+        for (const line of queue.summaryLines) {
+            lines.push(`- ${line}`);
+        }
+    }
+    queue.droppedCount = 0;
+    queue.summaryLines = [];
+    return lines.join("\n");
+}
+function buildCollectPrompt(items, summary) {
+    const blocks = ["[Queued messages while agent was busy]"];
+    if (summary) {
+        blocks.push(summary);
+    }
+    items.forEach((item, idx) => {
+        blocks.push(`---\nQueued #${idx + 1}\n${item.prompt}`.trim());
+    });
+    return blocks.join("\n\n");
+}
+export function scheduleFollowupDrain(key, runFollowup) {
+    const queue = FOLLOWUP_QUEUES.get(key);
+    if (!queue || queue.draining)
+        return;
+    queue.draining = true;
+    void (async () => {
+        try {
+            while (queue.items.length > 0 || queue.droppedCount > 0) {
+                await waitForQueueDebounce(queue);
+                if (queue.mode === "collect") {
+                    const items = queue.items.splice(0, queue.items.length);
+                    const summary = buildSummaryPrompt(queue);
+                    const run = items.at(-1)?.run ?? queue.lastRun;
+                    if (!run)
+                        break;
+                    const prompt = buildCollectPrompt(items, summary);
+                    await runFollowup({
+                        prompt,
+                        run,
+                        enqueuedAt: Date.now(),
+                    });
+                    continue;
+                }
+                const summaryPrompt = buildSummaryPrompt(queue);
+                if (summaryPrompt) {
+                    const run = queue.lastRun;
+                    if (!run)
+                        break;
+                    await runFollowup({
+                        prompt: summaryPrompt,
+                        run,
+                        enqueuedAt: Date.now(),
+                    });
+                    continue;
+                }
+                const next = queue.items.shift();
+                if (!next)
+                    break;
+                await runFollowup(next);
+            }
+        }
+        catch (err) {
+            defaultRuntime.error?.(`followup queue drain failed for ${key}: ${String(err)}`);
+        }
+        finally {
+            queue.draining = false;
+            if (queue.items.length === 0 && queue.droppedCount === 0) {
+                FOLLOWUP_QUEUES.delete(key);
+            }
+            else {
+                scheduleFollowupDrain(key, runFollowup);
+            }
+        }
+    })();
+}
+function defaultQueueModeForProvider(provider) {
+    const normalized = provider?.trim().toLowerCase();
+    if (normalized === "discord")
+        return "collect";
+    if (normalized === "webchat")
+        return "collect";
+    if (normalized === "whatsapp")
+        return "collect";
+    if (normalized === "telegram")
+        return "collect";
+    if (normalized === "imessage")
+        return "collect";
+    if (normalized === "signal")
+        return "collect";
+    return "collect";
+}
+export function resolveQueueSettings(params) {
+    const providerKey = params.provider?.trim().toLowerCase();
+    const queueCfg = params.cfg.routing?.queue;
+    const providerModeRaw = providerKey && queueCfg?.byProvider
+        ? queueCfg.byProvider[providerKey]
+        : undefined;
+    const resolvedMode = params.inlineMode ??
+        normalizeQueueMode(params.sessionEntry?.queueMode) ??
+        normalizeQueueMode(providerModeRaw) ??
+        normalizeQueueMode(queueCfg?.mode) ??
+        defaultQueueModeForProvider(providerKey);
+    const debounceRaw = params.inlineOptions?.debounceMs ??
+        params.sessionEntry?.queueDebounceMs ??
+        queueCfg?.debounceMs ??
+        DEFAULT_QUEUE_DEBOUNCE_MS;
+    const capRaw = params.inlineOptions?.cap ??
+        params.sessionEntry?.queueCap ??
+        queueCfg?.cap ??
+        DEFAULT_QUEUE_CAP;
+    const dropRaw = params.inlineOptions?.dropPolicy ??
+        params.sessionEntry?.queueDrop ??
+        normalizeQueueDropPolicy(queueCfg?.drop) ??
+        DEFAULT_QUEUE_DROP;
+    return {
+        mode: resolvedMode,
+        debounceMs: typeof debounceRaw === "number" ? Math.max(0, debounceRaw) : undefined,
+        cap: typeof capRaw === "number" ? Math.max(1, Math.floor(capRaw)) : undefined,
+        dropPolicy: dropRaw,
+    };
+}

package/dist/auto-reply/reply/reply-dispatcher.js

@@ -0,0 +1,68 @@
+import { stripHeartbeatToken } from "../heartbeat.js";
+import { HEARTBEAT_TOKEN, SILENT_REPLY_TOKEN } from "../tokens.js";
+function normalizeReplyPayload(payload, opts) {
+    const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
+    const trimmed = payload.text?.trim() ?? "";
+    if (!trimmed && !hasMedia)
+        return null;
+    // Avoid sending the explicit silent token when no media is attached.
+    if (trimmed === SILENT_REPLY_TOKEN && !hasMedia)
+        return null;
+    let text = payload.text ?? undefined;
+    if (text && !trimmed) {
+        // Keep empty text when media exists so media-only replies still send.
+        text = "";
+    }
+    if (text?.includes(HEARTBEAT_TOKEN)) {
+        const stripped = stripHeartbeatToken(text, { mode: "message" });
+        if (stripped.didStrip)
+            opts.onHeartbeatStrip?.();
+        if (stripped.shouldSkip && !hasMedia)
+            return null;
+        text = stripped.text;
+    }
+    if (opts.responsePrefix &&
+        text &&
+        text.trim() !== HEARTBEAT_TOKEN &&
+        !text.startsWith(opts.responsePrefix)) {
+        text = `${opts.responsePrefix} ${text}`;
+    }
+    return { ...payload, text };
+}
+export function createReplyDispatcher(options) {
+    let sendChain = Promise.resolve();
+    // Track in-flight deliveries so we can emit a reliable "idle" signal.
+    let pending = 0;
+    // Serialize outbound replies to preserve tool/block/final order.
+    const queuedCounts = {
+        tool: 0,
+        block: 0,
+        final: 0,
+    };
+    const enqueue = (kind, payload) => {
+        const normalized = normalizeReplyPayload(payload, options);
+        if (!normalized)
+            return false;
+        queuedCounts[kind] += 1;
+        pending += 1;
+        sendChain = sendChain
+            .then(() => options.deliver(normalized, { kind }))
+            .catch((err) => {
+            options.onError?.(err, { kind });
+        })
+            .finally(() => {
+            pending -= 1;
+            if (pending === 0) {
+                options.onIdle?.();
+            }
+        });
+        return true;
+    };
+    return {
+        sendToolResult: (payload) => enqueue("tool", payload),
+        sendBlockReply: (payload) => enqueue("block", payload),
+        sendFinalReply: (payload) => enqueue("final", payload),
+        waitForIdle: () => sendChain,
+        getQueuedCounts: () => ({ ...queuedCounts }),
+    };
+}

package/dist/auto-reply/reply/reply-tags.js

@@ -0,0 +1,26 @@
+export function extractReplyToTag(text, currentMessageId) {
+    if (!text)
+        return { cleaned: "", hasTag: false };
+    let cleaned = text;
+    let replyToId;
+    let hasTag = false;
+    const currentMatch = cleaned.match(/\[\[reply_to_current\]\]/i);
+    if (currentMatch) {
+        cleaned = cleaned.replace(/\[\[reply_to_current\]\]/gi, " ");
+        hasTag = true;
+        if (currentMessageId?.trim()) {
+            replyToId = currentMessageId.trim();
+        }
+    }
+    const idMatch = cleaned.match(/\[\[reply_to:([^\]\n]+)\]\]/i);
+    if (idMatch?.[1]) {
+        cleaned = cleaned.replace(/\[\[reply_to:[^\]\n]+\]\]/gi, " ");
+        replyToId = idMatch[1].trim();
+        hasTag = true;
+    }
+    cleaned = cleaned
+        .replace(/[ \t]+/g, " ")
+        .replace(/[ \t]*\n[ \t]*/g, "\n")
+        .trim();
+    return { cleaned, replyToId, hasTag };
+}

package/dist/auto-reply/reply/session-updates.js

@@ -0,0 +1,103 @@
+import crypto from "node:crypto";
+import { buildWorkspaceSkillSnapshot } from "../../agents/skills.js";
+import { saveSessionStore } from "../../config/sessions.js";
+import { buildProviderSummary } from "../../infra/provider-summary.js";
+import { drainSystemEvents } from "../../infra/system-events.js";
+export async function prependSystemEvents(params) {
+    const compactSystemEvent = (line) => {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return null;
+        const lower = trimmed.toLowerCase();
+        if (lower.includes("reason periodic"))
+            return null;
+        if (lower.includes("heartbeat"))
+            return null;
+        if (trimmed.startsWith("Node:")) {
+            return trimmed.replace(/ · last input [^·]+/i, "").trim();
+        }
+        return trimmed;
+    };
+    const systemLines = [];
+    const queued = drainSystemEvents(params.sessionKey);
+    systemLines.push(...queued.map(compactSystemEvent).filter((v) => Boolean(v)));
+    if (params.isMainSession && params.isNewSession) {
+        const summary = await buildProviderSummary(params.cfg);
+        if (summary.length > 0)
+            systemLines.unshift(...summary);
+    }
+    if (systemLines.length === 0)
+        return params.prefixedBodyBase;
+    const block = systemLines.map((l) => `System: ${l}`).join("\n");
+    return `${block}\n\n${params.prefixedBodyBase}`;
+}
+export async function ensureSkillSnapshot(params) {
+    const { sessionEntry, sessionStore, sessionKey, storePath, sessionId, isFirstTurnInSession, workspaceDir, cfg, } = params;
+    let nextEntry = sessionEntry;
+    let systemSent = sessionEntry?.systemSent ?? false;
+    if (isFirstTurnInSession && sessionStore && sessionKey) {
+        const current = nextEntry ??
+            sessionStore[sessionKey] ?? {
+            sessionId: sessionId ?? crypto.randomUUID(),
+            updatedAt: Date.now(),
+        };
+        const skillSnapshot = isFirstTurnInSession || !current.skillsSnapshot
+            ? buildWorkspaceSkillSnapshot(workspaceDir, { config: cfg })
+            : current.skillsSnapshot;
+        nextEntry = {
+            ...current,
+            sessionId: sessionId ?? current.sessionId ?? crypto.randomUUID(),
+            updatedAt: Date.now(),
+            systemSent: true,
+            skillsSnapshot: skillSnapshot,
+        };
+        sessionStore[sessionKey] = nextEntry;
+        if (storePath) {
+            await saveSessionStore(storePath, sessionStore);
+        }
+        systemSent = true;
+    }
+    const skillsSnapshot = nextEntry?.skillsSnapshot ??
+        (isFirstTurnInSession
+            ? undefined
+            : buildWorkspaceSkillSnapshot(workspaceDir, { config: cfg }));
+    if (skillsSnapshot &&
+        sessionStore &&
+        sessionKey &&
+        !isFirstTurnInSession &&
+        !nextEntry?.skillsSnapshot) {
+        const current = nextEntry ?? {
+            sessionId: sessionId ?? crypto.randomUUID(),
+            updatedAt: Date.now(),
+        };
+        nextEntry = {
+            ...current,
+            sessionId: sessionId ?? current.sessionId ?? crypto.randomUUID(),
+            updatedAt: Date.now(),
+            skillsSnapshot,
+        };
+        sessionStore[sessionKey] = nextEntry;
+        if (storePath) {
+            await saveSessionStore(storePath, sessionStore);
+        }
+    }
+    return { sessionEntry: nextEntry, skillsSnapshot, systemSent };
+}
+export async function incrementCompactionCount(params) {
+    const { sessionEntry, sessionStore, sessionKey, storePath, now = Date.now(), } = params;
+    if (!sessionStore || !sessionKey)
+        return undefined;
+    const entry = sessionStore[sessionKey] ?? sessionEntry;
+    if (!entry)
+        return undefined;
+    const nextCount = (entry.compactionCount ?? 0) + 1;
+    sessionStore[sessionKey] = {
+        ...entry,
+        compactionCount: nextCount,
+        updatedAt: now,
+    };
+    if (storePath) {
+        await saveSessionStore(storePath, sessionStore);
+    }
+    return nextCount;
+}