@intent-systems/nexus 2026.1.5-11

package/dist/agents/workspace.js

@@ -0,0 +1,286 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveBootstrapPath, resolveStateDir } from "../config/paths.js";
+import { NEXUS_ROOT, SKILLS_STATE_DIR, resolveUserPath } from "../utils.js";
+export function resolveDefaultAgentWorkspaceDir(env = process.env, homedir = os.homedir) {
+    const profile = env.NEXUS_PROFILE?.trim();
+    if (profile && profile.toLowerCase() !== "default") {
+        return path.join(homedir(), "nexus", `home-${profile}`);
+    }
+    return path.join(homedir(), "nexus", "home");
+}
+export const DEFAULT_AGENT_WORKSPACE_DIR = resolveDefaultAgentWorkspaceDir();
+export const DEFAULT_AGENTS_FILENAME = "AGENTS.md";
+export const DEFAULT_SOUL_FILENAME = "SOUL.md";
+export const DEFAULT_TOOLS_FILENAME = "TOOLS.md";
+export const DEFAULT_IDENTITY_FILENAME = "IDENTITY.md";
+export const DEFAULT_USER_FILENAME = "IDENTITY.md";
+export const DEFAULT_USER_TEMPLATE_NAME = "USER.md";
+export const DEFAULT_BOOTSTRAP_FILENAME = "BOOTSTRAP.md";
+const DEFAULT_AGENTS_TEMPLATE = `# AGENTS.md - Nexus Workspace
+
+This workspace uses Nexus. Nexus is the source of truth; agents are guests who follow Nexus protocols.
+
+## First action (always)
+Run:
+\`\`\`bash
+nexus status
+\`\`\`
+
+That command tells you who you are, what you can do, and what to do next.
+
+## Identity & memory
+- Agent identity: state/agents/{agent}/IDENTITY.md
+- Agent values: state/agents/{agent}/SOUL.md
+- Agent memory: state/agents/{agent}/MEMORY.md
+- User identity: state/user/IDENTITY.md
+
+## User workspace
+The user-owned workspace lives in home/. Do not modify it without permission.
+
+## Safety defaults
+- Don't exfiltrate secrets or private data.
+- Don't run destructive commands unless explicitly asked.
+- Be concise in chat; write longer output to files in home/.
+`;
+const DEFAULT_SOUL_TEMPLATE = `# SOUL.md - Persona & Boundaries
+
+Describe who the assistant is, tone, and boundaries.
+
+- Keep replies concise and direct.
+- Ask clarifying questions when needed.
+- Never send streaming/partial replies to external messaging surfaces.
+`;
+const DEFAULT_TOOLS_TEMPLATE = `# TOOLS.md - User Tool Notes (editable)
+
+This file is for *your* notes about external tools and conventions.
+It does not define which tools exist; Nexus provides built-in tools internally.
+
+## Examples
+
+### imsg
+- Send an iMessage/SMS: describe who/what, confirm before sending.
+- Prefer short messages; avoid sending secrets.
+
+### sag
+- Text-to-speech: specify voice, target speaker/room, and whether to stream.
+
+Add whatever else you want the assistant to know about your local toolchain.
+`;
+const DEFAULT_BOOTSTRAP_TEMPLATE = `# BOOTSTRAP.md - Welcome to Nexus
+
+This workspace needs identity setup before agents can help.
+
+## For humans
+Start a short conversation with your AI assistant. Share:
+- Your name (and how you'd like to be addressed)
+- What you're hoping to accomplish with AI
+- Any preferences for tone, boundaries, or style
+
+The agent will write identity files as you chat (takes ~5 min).
+
+## For agents
+You are beginning the bootstrap conversation. Goals:
+
+1) Learn the user's name
+   → Write: state/user/IDENTITY.md
+
+2) Let the user name you
+   → Write: state/agents/{agent}/IDENTITY.md
+
+3) Define personality and boundaries
+   → Write: state/agents/{agent}/SOUL.md
+
+4) Initialize long-term memory
+   → Write: state/agents/{agent}/MEMORY.md
+
+Be warm, curious, and conversational. Don't rush a checklist.
+
+When complete, run \`nexus status\` to show what's unlocked.
+`;
+const DEFAULT_IDENTITY_TEMPLATE = `---
+name:
+emoji:
+creature:
+vibe:
+---
+# IDENTITY.md - Agent Identity
+
+- Name:
+- Creature:
+- Vibe:
+- Emoji:
+`;
+const DEFAULT_USER_TEMPLATE = `---
+name:
+call:
+pronouns:
+timezone:
+---
+# IDENTITY.md - About Your Human
+
+- Name:
+- What to call them:
+- Pronouns (optional):
+- Timezone (optional):
+- Notes:
+`;
+const DEFAULT_MEMORY_TEMPLATE = `# MEMORY.md - Long-Term Memory
+
+This file stores distilled, long-term insights about the user and context.
+Keep it concise and updated as you learn important facts.
+`;
+const TEMPLATE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../docs/templates");
+function stripFrontMatter(content) {
+    if (!content.startsWith("---"))
+        return content;
+    const endIndex = content.indexOf("\n---", 3);
+    if (endIndex === -1)
+        return content;
+    const start = endIndex + "\n---".length;
+    let trimmed = content.slice(start);
+    trimmed = trimmed.replace(/^\s+/, "");
+    return trimmed;
+}
+async function loadTemplate(name, fallback) {
+    const templatePath = path.join(TEMPLATE_DIR, name);
+    try {
+        const content = await fs.readFile(templatePath, "utf-8");
+        return stripFrontMatter(content);
+    }
+    catch {
+        return fallback;
+    }
+}
+async function writeFileIfMissing(filePath, content) {
+    try {
+        await fs.writeFile(filePath, content, {
+            encoding: "utf-8",
+            flag: "wx",
+        });
+    }
+    catch (err) {
+        const anyErr = err;
+        if (anyErr.code !== "EEXIST")
+            throw err;
+    }
+}
+export async function ensureAgentWorkspace(params) {
+    const rawDir = params?.dir?.trim()
+        ? params.dir.trim()
+        : DEFAULT_AGENT_WORKSPACE_DIR;
+    const dir = resolveUserPath(rawDir);
+    const createHomeLayout = params?.createHomeLayout ?? false;
+    await fs.mkdir(dir, { recursive: true });
+    if (createHomeLayout) {
+        await fs.mkdir(path.join(dir, "memory"), { recursive: true });
+        await fs.mkdir(path.join(dir, "projects"), { recursive: true });
+    }
+    await fs.mkdir(NEXUS_ROOT, { recursive: true });
+    const stateDir = resolveStateDir();
+    const nexusStateDir = path.join(stateDir, "nexus");
+    const agentId = process.env.NEXUS_AGENT_ID?.trim() || "default";
+    const agentIdentityDir = path.join(stateDir, "agents", agentId);
+    const userIdentityDir = path.join(stateDir, "user");
+    const skillsStateDir = SKILLS_STATE_DIR;
+    const credentialsDir = path.join(stateDir, "credentials");
+    await fs.mkdir(nexusStateDir, { recursive: true });
+    await fs.mkdir(agentIdentityDir, { recursive: true });
+    await fs.mkdir(userIdentityDir, { recursive: true });
+    await fs.mkdir(skillsStateDir, { recursive: true });
+    await fs.mkdir(credentialsDir, { recursive: true });
+    const agentsPath = path.join(NEXUS_ROOT, DEFAULT_AGENTS_FILENAME);
+    const soulPath = path.join(agentIdentityDir, DEFAULT_SOUL_FILENAME);
+    const toolsPath = path.join(dir, DEFAULT_TOOLS_FILENAME);
+    const identityPath = path.join(agentIdentityDir, DEFAULT_IDENTITY_FILENAME);
+    const memoryPath = path.join(agentIdentityDir, "MEMORY.md");
+    const userPath = path.join(userIdentityDir, DEFAULT_USER_FILENAME);
+    const bootstrapPath = resolveBootstrapPath();
+    const agentsTemplate = await loadTemplate(DEFAULT_AGENTS_FILENAME, DEFAULT_AGENTS_TEMPLATE);
+    await writeFileIfMissing(agentsPath, agentsTemplate);
+    if (params?.ensureBootstrapFiles) {
+        const bootstrapMode = params.bootstrapMode ?? "full";
+        const soulTemplate = await loadTemplate(DEFAULT_SOUL_FILENAME, DEFAULT_SOUL_TEMPLATE);
+        const toolsTemplate = await loadTemplate(DEFAULT_TOOLS_FILENAME, DEFAULT_TOOLS_TEMPLATE);
+        const identityTemplate = await loadTemplate(DEFAULT_IDENTITY_FILENAME, DEFAULT_IDENTITY_TEMPLATE);
+        const userTemplate = await loadTemplate(DEFAULT_USER_TEMPLATE_NAME, DEFAULT_USER_TEMPLATE);
+        const memoryTemplate = DEFAULT_MEMORY_TEMPLATE;
+        const bootstrapTemplate = await loadTemplate(DEFAULT_BOOTSTRAP_FILENAME, DEFAULT_BOOTSTRAP_TEMPLATE);
+        if (createHomeLayout) {
+            await writeFileIfMissing(toolsPath, toolsTemplate);
+        }
+        await writeFileIfMissing(bootstrapPath, bootstrapTemplate);
+        await writeFileIfMissing(soulPath, soulTemplate);
+        if (bootstrapMode === "full") {
+            await writeFileIfMissing(identityPath, identityTemplate);
+            await writeFileIfMissing(memoryPath, memoryTemplate);
+            await writeFileIfMissing(userPath, userTemplate);
+        }
+    }
+    return {
+        dir,
+        agentsPath,
+        soulPath,
+        toolsPath,
+        identityPath,
+        memoryPath,
+        userPath,
+        bootstrapPath,
+    };
+}
+export async function loadWorkspaceBootstrapFiles(dir) {
+    const resolvedDir = resolveUserPath(dir);
+    const stateDir = resolveStateDir();
+    const agentId = process.env.NEXUS_AGENT_ID?.trim() || "default";
+    const agentIdentityDir = path.join(stateDir, "agents", agentId);
+    const userIdentityDir = path.join(stateDir, "user");
+    const bootstrapPath = resolveBootstrapPath();
+    const entries = [
+        {
+            name: DEFAULT_AGENTS_FILENAME,
+            filePath: path.join(NEXUS_ROOT, DEFAULT_AGENTS_FILENAME),
+        },
+        {
+            name: DEFAULT_SOUL_FILENAME,
+            filePath: path.join(agentIdentityDir, DEFAULT_SOUL_FILENAME),
+        },
+        {
+            name: DEFAULT_TOOLS_FILENAME,
+            filePath: path.join(resolvedDir, DEFAULT_TOOLS_FILENAME),
+        },
+        {
+            name: DEFAULT_IDENTITY_FILENAME,
+            filePath: path.join(agentIdentityDir, DEFAULT_IDENTITY_FILENAME),
+        },
+        {
+            name: "MEMORY.md",
+            filePath: path.join(agentIdentityDir, "MEMORY.md"),
+        },
+        {
+            name: DEFAULT_USER_FILENAME,
+            filePath: path.join(userIdentityDir, DEFAULT_USER_FILENAME),
+        },
+        {
+            name: DEFAULT_BOOTSTRAP_FILENAME,
+            filePath: bootstrapPath,
+        },
+    ];
+    const result = [];
+    for (const entry of entries) {
+        try {
+            const content = await fs.readFile(entry.filePath, "utf-8");
+            result.push({
+                name: entry.name,
+                path: entry.filePath,
+                content,
+                missing: false,
+            });
+        }
+        catch {
+            result.push({ name: entry.name, path: entry.filePath, missing: true });
+        }
+    }
+    return result;
+}

package/dist/auto-reply/chunk.js

@@ -0,0 +1,177 @@
+// Utilities for splitting outbound text into platform-sized chunks without
+// unintentionally breaking on newlines. Using [\s\S] keeps newlines inside
+// the chunk so messages are only split when they truly exceed the limit.
+import { findFenceSpanAt, isSafeFenceBreak, parseFenceSpans, } from "../markdown/fences.js";
+const DEFAULT_CHUNK_LIMIT_BY_PROVIDER = {
+    whatsapp: 4000,
+    telegram: 4000,
+    discord: 2000,
+    slack: 4000,
+    signal: 4000,
+    imessage: 4000,
+    webchat: 4000,
+};
+export function resolveTextChunkLimit(cfg, provider) {
+    const providerOverride = (() => {
+        if (!provider)
+            return undefined;
+        if (provider === "whatsapp")
+            return cfg?.whatsapp?.textChunkLimit;
+        if (provider === "telegram")
+            return cfg?.telegram?.textChunkLimit;
+        if (provider === "discord")
+            return cfg?.discord?.textChunkLimit;
+        if (provider === "slack")
+            return cfg?.slack?.textChunkLimit;
+        if (provider === "signal")
+            return cfg?.signal?.textChunkLimit;
+        if (provider === "imessage")
+            return cfg?.imessage?.textChunkLimit;
+        return undefined;
+    })();
+    if (typeof providerOverride === "number" && providerOverride > 0) {
+        return providerOverride;
+    }
+    if (provider)
+        return DEFAULT_CHUNK_LIMIT_BY_PROVIDER[provider];
+    return 4000;
+}
+export function chunkText(text, limit) {
+    if (!text)
+        return [];
+    if (limit <= 0)
+        return [text];
+    if (text.length <= limit)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > limit) {
+        const window = remaining.slice(0, limit);
+        // 1) Prefer a newline break inside the window.
+        let breakIdx = window.lastIndexOf("\n");
+        // 2) Otherwise prefer the last whitespace (word boundary) inside the window.
+        if (breakIdx <= 0) {
+            for (let i = window.length - 1; i >= 0; i--) {
+                if (/\s/.test(window[i])) {
+                    breakIdx = i;
+                    break;
+                }
+            }
+        }
+        // 3) Fallback: hard break exactly at the limit.
+        if (breakIdx <= 0)
+            breakIdx = limit;
+        const rawChunk = remaining.slice(0, breakIdx);
+        const chunk = rawChunk.trimEnd();
+        if (chunk.length > 0) {
+            chunks.push(chunk);
+        }
+        // If we broke on whitespace/newline, skip that separator; for hard breaks keep it.
+        const brokeOnSeparator = breakIdx < remaining.length && /\s/.test(remaining[breakIdx]);
+        const nextStart = Math.min(remaining.length, breakIdx + (brokeOnSeparator ? 1 : 0));
+        remaining = remaining.slice(nextStart).trimStart();
+    }
+    if (remaining.length)
+        chunks.push(remaining);
+    return chunks;
+}
+export function chunkMarkdownText(text, limit) {
+    if (!text)
+        return [];
+    if (limit <= 0)
+        return [text];
+    if (text.length <= limit)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > limit) {
+        const spans = parseFenceSpans(remaining);
+        const window = remaining.slice(0, limit);
+        const softBreak = pickSafeBreakIndex(window, spans);
+        let breakIdx = softBreak > 0 ? softBreak : limit;
+        const initialFence = isSafeFenceBreak(spans, breakIdx)
+            ? undefined
+            : findFenceSpanAt(spans, breakIdx);
+        let fenceToSplit = initialFence;
+        if (initialFence) {
+            const closeLine = `${initialFence.indent}${initialFence.marker}`;
+            const maxIdxIfNeedNewline = limit - (closeLine.length + 1);
+            if (maxIdxIfNeedNewline <= 0) {
+                fenceToSplit = undefined;
+                breakIdx = limit;
+            }
+            else {
+                const minProgressIdx = Math.min(remaining.length, initialFence.start + initialFence.openLine.length + 2);
+                const maxIdxIfAlreadyNewline = limit - closeLine.length;
+                let pickedNewline = false;
+                let lastNewline = remaining.lastIndexOf("\n", Math.max(0, maxIdxIfAlreadyNewline - 1));
+                while (lastNewline !== -1) {
+                    const candidateBreak = lastNewline + 1;
+                    if (candidateBreak < minProgressIdx)
+                        break;
+                    const candidateFence = findFenceSpanAt(spans, candidateBreak);
+                    if (candidateFence && candidateFence.start === initialFence.start) {
+                        breakIdx = Math.max(1, candidateBreak);
+                        pickedNewline = true;
+                        break;
+                    }
+                    lastNewline = remaining.lastIndexOf("\n", lastNewline - 1);
+                }
+                if (!pickedNewline) {
+                    if (minProgressIdx > maxIdxIfAlreadyNewline) {
+                        fenceToSplit = undefined;
+                        breakIdx = limit;
+                    }
+                    else {
+                        breakIdx = Math.max(minProgressIdx, maxIdxIfNeedNewline);
+                    }
+                }
+            }
+            const fenceAtBreak = findFenceSpanAt(spans, breakIdx);
+            fenceToSplit =
+                fenceAtBreak && fenceAtBreak.start === initialFence.start
+                    ? fenceAtBreak
+                    : undefined;
+        }
+        let rawChunk = remaining.slice(0, breakIdx);
+        if (!rawChunk)
+            break;
+        const brokeOnSeparator = breakIdx < remaining.length && /\s/.test(remaining[breakIdx]);
+        const nextStart = Math.min(remaining.length, breakIdx + (brokeOnSeparator ? 1 : 0));
+        let next = remaining.slice(nextStart);
+        if (fenceToSplit) {
+            const closeLine = `${fenceToSplit.indent}${fenceToSplit.marker}`;
+            rawChunk = rawChunk.endsWith("\n")
+                ? `${rawChunk}${closeLine}`
+                : `${rawChunk}\n${closeLine}`;
+            next = `${fenceToSplit.openLine}\n${next}`;
+        }
+        else {
+            next = stripLeadingNewlines(next);
+        }
+        chunks.push(rawChunk);
+        remaining = next;
+    }
+    if (remaining.length)
+        chunks.push(remaining);
+    return chunks;
+}
+function stripLeadingNewlines(value) {
+    let i = 0;
+    while (i < value.length && value[i] === "\n")
+        i++;
+    return i > 0 ? value.slice(i) : value;
+}
+function pickSafeBreakIndex(window, spans) {
+    let newlineIdx = window.lastIndexOf("\n");
+    while (newlineIdx > 0) {
+        if (isSafeFenceBreak(spans, newlineIdx))
+            return newlineIdx;
+        newlineIdx = window.lastIndexOf("\n", newlineIdx - 1);
+    }
+    for (let i = window.length - 1; i > 0; i--) {
+        if (/\s/.test(window[i]) && isSafeFenceBreak(spans, i))
+            return i;
+    }
+    return -1;
+}

package/dist/auto-reply/command-auth.js

@@ -0,0 +1,44 @@
+import { normalizeE164 } from "../utils.js";
+export function resolveCommandAuthorization(params) {
+    const { ctx, cfg, commandAuthorized } = params;
+    const provider = (ctx.Provider ?? "").trim().toLowerCase();
+    const from = (ctx.From ?? "").replace(/^whatsapp:/, "");
+    const to = (ctx.To ?? "").replace(/^whatsapp:/, "");
+    const hasWhatsappPrefix = (ctx.From ?? "").startsWith("whatsapp:") ||
+        (ctx.To ?? "").startsWith("whatsapp:");
+    const looksLikeE164 = (value) => Boolean(value && /^\+?\d{3,}$/.test(value.replace(/[^\d+]/g, "")));
+    const inferWhatsApp = !provider &&
+        Boolean(cfg.whatsapp?.allowFrom?.length) &&
+        (looksLikeE164(from) || looksLikeE164(to));
+    const isWhatsAppProvider = provider === "whatsapp" || hasWhatsappPrefix || inferWhatsApp;
+    const configuredAllowFrom = isWhatsAppProvider
+        ? cfg.whatsapp?.allowFrom
+        : undefined;
+    const allowFromList = configuredAllowFrom?.filter((entry) => entry?.trim()) ?? [];
+    const allowAll = !isWhatsAppProvider ||
+        allowFromList.length === 0 ||
+        allowFromList.some((entry) => entry.trim() === "*");
+    const senderE164 = normalizeE164(ctx.SenderE164 ?? (isWhatsAppProvider ? from : ""));
+    const ownerCandidates = isWhatsAppProvider && !allowAll
+        ? allowFromList.filter((entry) => entry !== "*")
+        : [];
+    if (isWhatsAppProvider && !allowAll && ownerCandidates.length === 0 && to) {
+        ownerCandidates.push(to);
+    }
+    const ownerList = ownerCandidates
+        .map((entry) => normalizeE164(entry))
+        .filter((entry) => Boolean(entry));
+    const isOwner = !isWhatsAppProvider ||
+        allowAll ||
+        ownerList.length === 0 ||
+        (senderE164 ? ownerList.includes(senderE164) : false);
+    const isAuthorizedSender = commandAuthorized && isOwner;
+    return {
+        isWhatsAppProvider,
+        ownerList,
+        senderE164: senderE164 || undefined,
+        isAuthorizedSender,
+        from: from || undefined,
+        to: to || undefined,
+    };
+}

package/dist/auto-reply/command-detection.js

@@ -0,0 +1,23 @@
+const CONTROL_COMMAND_RE = /(?:^|\s)\/(?:status|help|thinking|think|t|reasoning|reason|verbose|v|elevated|elev|model|queue|activation|send|restart|reset|new|compact)(?=$|\s|:)\b/i;
+const CONTROL_COMMAND_EXACT = new Set([
+    "/help",
+    "/status",
+    "/restart",
+    "/activation",
+    "/send",
+    "/reasoning",
+    "/reset",
+    "/new",
+    "/compact",
+]);
+export function hasControlCommand(text) {
+    if (!text)
+        return false;
+    const trimmed = text.trim();
+    if (!trimmed)
+        return false;
+    const lowered = trimmed.toLowerCase();
+    if (CONTROL_COMMAND_EXACT.has(lowered))
+        return true;
+    return CONTROL_COMMAND_RE.test(text);
+}

package/dist/auto-reply/envelope.js

@@ -0,0 +1,30 @@
+function formatTimestamp(ts) {
+    if (!ts)
+        return undefined;
+    const date = ts instanceof Date ? ts : new Date(ts);
+    if (Number.isNaN(date.getTime()))
+        return undefined;
+    const yyyy = String(date.getUTCFullYear()).padStart(4, "0");
+    const mm = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const dd = String(date.getUTCDate()).padStart(2, "0");
+    const hh = String(date.getUTCHours()).padStart(2, "0");
+    const min = String(date.getUTCMinutes()).padStart(2, "0");
+    // Compact ISO-like UTC timestamp with minutes precision.
+    // Example: 2025-01-02T03:04Z
+    return `${yyyy}-${mm}-${dd}T${hh}:${min}Z`;
+}
+export function formatAgentEnvelope(params) {
+    const provider = params.provider?.trim() || "Provider";
+    const parts = [provider];
+    if (params.from?.trim())
+        parts.push(params.from.trim());
+    if (params.host?.trim())
+        parts.push(params.host.trim());
+    if (params.ip?.trim())
+        parts.push(params.ip.trim());
+    const ts = formatTimestamp(params.timestamp);
+    if (ts)
+        parts.push(ts);
+    const header = `[${parts.join(" ")}]`;
+    return `${header} ${params.body}`;
+}

package/dist/auto-reply/group-activation.js

@@ -0,0 +1,20 @@
+export function normalizeGroupActivation(raw) {
+    const value = raw?.trim().toLowerCase();
+    if (value === "mention")
+        return "mention";
+    if (value === "always")
+        return "always";
+    return undefined;
+}
+export function parseActivationCommand(raw) {
+    if (!raw)
+        return { hasCommand: false };
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return { hasCommand: false };
+    const match = trimmed.match(/^\/activation\b(?:\s+([a-zA-Z]+))?/i);
+    if (!match)
+        return { hasCommand: false };
+    const mode = normalizeGroupActivation(match[1]);
+    return { hasCommand: true, mode };
+}

package/dist/auto-reply/heartbeat.js

@@ -0,0 +1,58 @@
+import { HEARTBEAT_TOKEN } from "./tokens.js";
+export const HEARTBEAT_PROMPT = "HEARTBEAT";
+export const DEFAULT_HEARTBEAT_ACK_MAX_CHARS = 30;
+function stripTokenAtEdges(raw) {
+    let text = raw.trim();
+    if (!text)
+        return { text: "", didStrip: false };
+    const token = HEARTBEAT_TOKEN;
+    if (!text.includes(token))
+        return { text, didStrip: false };
+    let didStrip = false;
+    let changed = true;
+    while (changed) {
+        changed = false;
+        const next = text.trim();
+        if (next.startsWith(token)) {
+            const after = next.slice(token.length).trimStart();
+            text = after;
+            didStrip = true;
+            changed = true;
+            continue;
+        }
+        if (next.endsWith(token)) {
+            const before = next.slice(0, Math.max(0, next.length - token.length));
+            text = before.trimEnd();
+            didStrip = true;
+            changed = true;
+        }
+    }
+    const collapsed = text.replace(/\s+/g, " ").trim();
+    return { text: collapsed, didStrip };
+}
+export function stripHeartbeatToken(raw, opts = {}) {
+    if (!raw)
+        return { shouldSkip: true, text: "", didStrip: false };
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return { shouldSkip: true, text: "", didStrip: false };
+    const mode = opts.mode ?? "message";
+    const maxAckChars = Math.max(0, opts.maxAckChars ?? DEFAULT_HEARTBEAT_ACK_MAX_CHARS);
+    if (!trimmed.includes(HEARTBEAT_TOKEN)) {
+        return { shouldSkip: false, text: trimmed, didStrip: false };
+    }
+    const stripped = stripTokenAtEdges(trimmed);
+    if (!stripped.didStrip) {
+        return { shouldSkip: false, text: trimmed, didStrip: false };
+    }
+    if (!stripped.text) {
+        return { shouldSkip: true, text: "", didStrip: true };
+    }
+    if (mode === "heartbeat") {
+        const rest = stripped.text.trim();
+        if (rest.length <= maxAckChars) {
+            return { shouldSkip: true, text: "", didStrip: true };
+        }
+    }
+    return { shouldSkip: false, text: stripped.text, didStrip: true };
+}

package/dist/auto-reply/model.js

@@ -0,0 +1,22 @@
+export function extractModelDirective(body) {
+    if (!body)
+        return { cleaned: "", hasDirective: false };
+    const match = body.match(/(?:^|\s)\/model(?=$|\s|:)\s*:?\s*([A-Za-z0-9_.:@-]+(?:\/[A-Za-z0-9_.:@-]+)?)?/i);
+    const raw = match?.[1]?.trim();
+    let rawModel = raw;
+    let rawProfile;
+    if (raw?.includes("@")) {
+        const parts = raw.split("@");
+        rawModel = parts[0]?.trim();
+        rawProfile = parts.slice(1).join("@").trim() || undefined;
+    }
+    const cleaned = match
+        ? body.replace(match[0], "").replace(/\s+/g, " ").trim()
+        : body.trim();
+    return {
+        cleaned,
+        rawModel,
+        rawProfile,
+        hasDirective: !!match,
+    };
+}

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

@@ -0,0 +1,14 @@
+const ABORT_TRIGGERS = new Set(["stop", "esc", "abort", "wait", "exit"]);
+const ABORT_MEMORY = new Map();
+export function isAbortTrigger(text) {
+    if (!text)
+        return false;
+    const normalized = text.trim().toLowerCase();
+    return ABORT_TRIGGERS.has(normalized);
+}
+export function getAbortMemory(key) {
+    return ABORT_MEMORY.get(key);
+}
+export function setAbortMemory(key, value) {
+    ABORT_MEMORY.set(key, value);
+}