@gguf/pigbot 0.0.6 → 0.0.7

package/dist/media-understanding/apply.js

@@ -1,9 +1,272 @@
+import path from "node:path";
 import { finalizeInboundContext } from "../auto-reply/reply/inbound-context.js";
+import { logVerbose, shouldLogVerbose } from "../globals.js";
+import { DEFAULT_INPUT_FILE_MAX_BYTES, DEFAULT_INPUT_FILE_MAX_CHARS, DEFAULT_INPUT_FILE_MIMES, DEFAULT_INPUT_MAX_REDIRECTS, DEFAULT_INPUT_PDF_MAX_PAGES, DEFAULT_INPUT_PDF_MAX_PIXELS, DEFAULT_INPUT_PDF_MIN_TEXT_CHARS, DEFAULT_INPUT_TIMEOUT_MS, extractFileContentFromSource, normalizeMimeList, normalizeMimeType, } from "../media/input-files.js";
 import { extractMediaUserText, formatAudioTranscripts, formatMediaUnderstandingBody, } from "./format.js";
 import { runWithConcurrency } from "./concurrency.js";
 import { resolveConcurrency } from "./resolve.js";
+import { resolveAttachmentKind } from "./attachments.js";
 import { buildProviderRegistry, createMediaAttachmentCache, normalizeMediaAttachments, runCapability, } from "./runner.js";
 const CAPABILITY_ORDER = ["image", "audio", "video"];
+const EXTRA_TEXT_MIMES = [
+    "application/xml",
+    "text/xml",
+    "application/x-yaml",
+    "text/yaml",
+    "application/yaml",
+    "application/javascript",
+    "text/javascript",
+    "text/tab-separated-values",
+];
+const TEXT_EXT_MIME = new Map([
+    [".csv", "text/csv"],
+    [".tsv", "text/tab-separated-values"],
+    [".txt", "text/plain"],
+    [".md", "text/markdown"],
+    [".log", "text/plain"],
+    [".ini", "text/plain"],
+    [".cfg", "text/plain"],
+    [".conf", "text/plain"],
+    [".env", "text/plain"],
+    [".json", "application/json"],
+    [".yaml", "text/yaml"],
+    [".yml", "text/yaml"],
+    [".xml", "application/xml"],
+]);
+const XML_ESCAPE_MAP = {
+    "<": "&lt;",
+    ">": "&gt;",
+    "&": "&amp;",
+    '"': "&quot;",
+    "'": "&apos;",
+};
+/**
+ * Escapes special XML characters in attribute values to prevent injection.
+ */
+function xmlEscapeAttr(value) {
+    return value.replace(/[<>&"']/g, (char) => XML_ESCAPE_MAP[char] ?? char);
+}
+function resolveFileLimits(cfg) {
+    const files = cfg.gateway?.http?.endpoints?.responses?.files;
+    return {
+        allowUrl: files?.allowUrl ?? true,
+        allowedMimes: normalizeMimeList(files?.allowedMimes, DEFAULT_INPUT_FILE_MIMES),
+        maxBytes: files?.maxBytes ?? DEFAULT_INPUT_FILE_MAX_BYTES,
+        maxChars: files?.maxChars ?? DEFAULT_INPUT_FILE_MAX_CHARS,
+        maxRedirects: files?.maxRedirects ?? DEFAULT_INPUT_MAX_REDIRECTS,
+        timeoutMs: files?.timeoutMs ?? DEFAULT_INPUT_TIMEOUT_MS,
+        pdf: {
+            maxPages: files?.pdf?.maxPages ?? DEFAULT_INPUT_PDF_MAX_PAGES,
+            maxPixels: files?.pdf?.maxPixels ?? DEFAULT_INPUT_PDF_MAX_PIXELS,
+            minTextChars: files?.pdf?.minTextChars ?? DEFAULT_INPUT_PDF_MIN_TEXT_CHARS,
+        },
+    };
+}
+function appendFileBlocks(body, blocks) {
+    if (!blocks || blocks.length === 0) {
+        return body ?? "";
+    }
+    const base = typeof body === "string" ? body.trim() : "";
+    const suffix = blocks.join("\n\n").trim();
+    if (!base) {
+        return suffix;
+    }
+    return `${base}\n\n${suffix}`.trim();
+}
+function resolveUtf16Charset(buffer) {
+    if (!buffer || buffer.length < 2)
+        return undefined;
+    const b0 = buffer[0];
+    const b1 = buffer[1];
+    if (b0 === 0xff && b1 === 0xfe) {
+        return "utf-16le";
+    }
+    if (b0 === 0xfe && b1 === 0xff) {
+        return "utf-16be";
+    }
+    const sampleLen = Math.min(buffer.length, 2048);
+    let zeroCount = 0;
+    for (let i = 0; i < sampleLen; i += 1) {
+        if (buffer[i] === 0)
+            zeroCount += 1;
+    }
+    if (zeroCount / sampleLen > 0.2) {
+        return "utf-16le";
+    }
+    return undefined;
+}
+function looksLikeUtf8Text(buffer) {
+    if (!buffer || buffer.length === 0)
+        return false;
+    const sampleLen = Math.min(buffer.length, 4096);
+    let printable = 0;
+    let other = 0;
+    for (let i = 0; i < sampleLen; i += 1) {
+        const byte = buffer[i];
+        if (byte === 0) {
+            other += 1;
+            continue;
+        }
+        if (byte === 9 || byte === 10 || byte === 13 || (byte >= 32 && byte <= 126)) {
+            printable += 1;
+        }
+        else {
+            other += 1;
+        }
+    }
+    const total = printable + other;
+    if (total === 0)
+        return false;
+    return printable / total > 0.85;
+}
+function decodeTextSample(buffer) {
+    if (!buffer || buffer.length === 0)
+        return "";
+    const sample = buffer.subarray(0, Math.min(buffer.length, 8192));
+    const utf16Charset = resolveUtf16Charset(sample);
+    if (utf16Charset === "utf-16be") {
+        const swapped = Buffer.alloc(sample.length);
+        for (let i = 0; i + 1 < sample.length; i += 2) {
+            swapped[i] = sample[i + 1];
+            swapped[i + 1] = sample[i];
+        }
+        return new TextDecoder("utf-16le").decode(swapped);
+    }
+    if (utf16Charset === "utf-16le") {
+        return new TextDecoder("utf-16le").decode(sample);
+    }
+    return new TextDecoder("utf-8").decode(sample);
+}
+function guessDelimitedMime(text) {
+    if (!text)
+        return undefined;
+    const line = text.split(/\r?\n/)[0] ?? "";
+    const tabs = (line.match(/\t/g) ?? []).length;
+    const commas = (line.match(/,/g) ?? []).length;
+    if (commas > 0) {
+        return "text/csv";
+    }
+    if (tabs > 0) {
+        return "text/tab-separated-values";
+    }
+    return undefined;
+}
+function resolveTextMimeFromName(name) {
+    if (!name)
+        return undefined;
+    const ext = path.extname(name).toLowerCase();
+    return TEXT_EXT_MIME.get(ext);
+}
+async function extractFileBlocks(params) {
+    const { attachments, cache, limits } = params;
+    if (!attachments || attachments.length === 0) {
+        return [];
+    }
+    const blocks = [];
+    for (const attachment of attachments) {
+        if (!attachment) {
+            continue;
+        }
+        const forcedTextMime = resolveTextMimeFromName(attachment.path ?? attachment.url ?? "");
+        const kind = forcedTextMime ? "document" : resolveAttachmentKind(attachment);
+        if (!forcedTextMime && (kind === "image" || kind === "video")) {
+            continue;
+        }
+        if (!limits.allowUrl && attachment.url && !attachment.path) {
+            if (shouldLogVerbose()) {
+                logVerbose(`media: file attachment skipped (url disabled) index=${attachment.index}`);
+            }
+            continue;
+        }
+        let bufferResult;
+        try {
+            bufferResult = await cache.getBuffer({
+                attachmentIndex: attachment.index,
+                maxBytes: limits.maxBytes,
+                timeoutMs: limits.timeoutMs,
+            });
+        }
+        catch (err) {
+            if (shouldLogVerbose()) {
+                logVerbose(`media: file attachment skipped (buffer): ${String(err)}`);
+            }
+            continue;
+        }
+        const nameHint = bufferResult?.fileName ?? attachment.path ?? attachment.url;
+        const forcedTextMimeResolved = forcedTextMime ?? resolveTextMimeFromName(nameHint ?? "");
+        const utf16Charset = resolveUtf16Charset(bufferResult?.buffer);
+        const textSample = decodeTextSample(bufferResult?.buffer);
+        const textLike = Boolean(utf16Charset) || looksLikeUtf8Text(bufferResult?.buffer);
+        if (!forcedTextMimeResolved && kind === "audio" && !textLike) {
+            continue;
+        }
+        const guessedDelimited = textLike ? guessDelimitedMime(textSample) : undefined;
+        const textHint = forcedTextMimeResolved ?? guessedDelimited ?? (textLike ? "text/plain" : undefined);
+        const rawMime = bufferResult?.mime ?? attachment.mime;
+        const mimeType = textHint ?? normalizeMimeType(rawMime);
+        // Log when MIME type is overridden from non-text to text for auditability
+        if (textHint && rawMime && !rawMime.startsWith("text/")) {
+            logVerbose(`media: MIME override from "${rawMime}" to "${textHint}" for index=${attachment.index}`);
+        }
+        if (!mimeType) {
+            if (shouldLogVerbose()) {
+                logVerbose(`media: file attachment skipped (unknown mime) index=${attachment.index}`);
+            }
+            continue;
+        }
+        const allowedMimes = new Set(limits.allowedMimes);
+        for (const extra of EXTRA_TEXT_MIMES) {
+            allowedMimes.add(extra);
+        }
+        if (mimeType.startsWith("text/")) {
+            allowedMimes.add(mimeType);
+        }
+        if (!allowedMimes.has(mimeType)) {
+            if (shouldLogVerbose()) {
+                logVerbose(`media: file attachment skipped (unsupported mime ${mimeType}) index=${attachment.index}`);
+            }
+            continue;
+        }
+        let extracted;
+        try {
+            const mediaType = utf16Charset ? `${mimeType}; charset=${utf16Charset}` : mimeType;
+            extracted = await extractFileContentFromSource({
+                source: {
+                    type: "base64",
+                    data: bufferResult.buffer.toString("base64"),
+                    mediaType,
+                    filename: bufferResult.fileName,
+                },
+                limits: {
+                    ...limits,
+                    allowedMimes,
+                },
+            });
+        }
+        catch (err) {
+            if (shouldLogVerbose()) {
+                logVerbose(`media: file attachment skipped (extract): ${String(err)}`);
+            }
+            continue;
+        }
+        const text = extracted?.text?.trim() ?? "";
+        let blockText = text;
+        if (!blockText) {
+            if (extracted?.images && extracted.images.length > 0) {
+                blockText = "[PDF content rendered to images; images not forwarded to model]";
+            }
+            else {
+                blockText = "[No extractable text]";
+            }
+        }
+        const safeName = (bufferResult.fileName ?? `file-${attachment.index + 1}`)
+            .replace(/[\r\n\t]+/g, " ")
+            .trim();
+        // Escape XML special characters in attributes to prevent injection
+        blocks.push(`<file name="${xmlEscapeAttr(safeName)}" mime="${xmlEscapeAttr(mimeType)}">\n${blockText}\n</file>`);
+    }
+    return blocks;
+}
 export async function applyMediaUnderstanding(params) {
     const { ctx, cfg } = params;
     const commandCandidates = [ctx.CommandBody, ctx.RawBody, ctx.Body];
@@ -14,6 +277,11 @@ export async function applyMediaUnderstanding(params) {
     const providerRegistry = buildProviderRegistry(params.providers);
     const cache = createMediaAttachmentCache(attachments);
     try {
+        const fileBlocks = await extractFileBlocks({
+            attachments,
+            cache,
+            limits: resolveFileLimits(cfg),
+        });
         const tasks = CAPABILITY_ORDER.map((capability) => async () => {
             const config = cfg.tools?.media?.[capability];
             return await runCapability({
@@ -62,7 +330,15 @@ export async function applyMediaUnderstanding(params) {
                 ctx.RawBody = originalUserText;
             }
             ctx.MediaUnderstanding = [...(ctx.MediaUnderstanding ?? []), ...outputs];
-            finalizeInboundContext(ctx, { forceBodyForAgent: true, forceBodyForCommands: true });
+        }
+        if (fileBlocks.length > 0) {
+            ctx.Body = appendFileBlocks(ctx.Body, fileBlocks);
+        }
+        if (outputs.length > 0 || fileBlocks.length > 0) {
+            finalizeInboundContext(ctx, {
+                forceBodyForAgent: true,
+                forceBodyForCommands: outputs.length > 0,
+            });
         }
         return {
             outputs,
@@ -70,6 +346,7 @@ export async function applyMediaUnderstanding(params) {
             appliedImage: outputs.some((output) => output.kind === "image.description"),
             appliedAudio: outputs.some((output) => output.kind === "audio.transcription"),
             appliedVideo: outputs.some((output) => output.kind === "video.description"),
+            appliedFile: fileBlocks.length > 0,
         };
     }
     finally {

package/dist/media-understanding/attachments.js

@@ -253,7 +253,7 @@ export class MediaAttachmentCache {
             timeoutMs: params.timeoutMs,
         });
         const extension = path.extname(bufferResult.fileName || "") || "";
-        const tmpPath = path.join(os.tmpdir(), `moltbot-media-${crypto.randomUUID()}${extension}`);
+        const tmpPath = path.join(os.tmpdir(), `openclaw-media-${crypto.randomUUID()}${extension}`);
         await fs.writeFile(tmpPath, bufferResult.buffer);
         entry.tempPath = tmpPath;
         entry.tempCleanup = async () => {

package/dist/media-understanding/providers/image.js

@@ -1,11 +1,11 @@
 import { complete } from "@mariozechner/pi-ai";
 import { discoverAuthStorage, discoverModels } from "@mariozechner/pi-coding-agent";
 import { getApiKeyForModel, requireApiKey } from "../../agents/model-auth.js";
-import { ensureMoltbotModelsJson } from "../../agents/models-config.js";
+import { ensureOpenClawModelsJson } from "../../agents/models-config.js";
 import { minimaxUnderstandImage } from "../../agents/minimax-vlm.js";
 import { coerceImageAssistantText } from "../../agents/tools/image-tool.helpers.js";
 export async function describeImageWithModel(params) {
-    await ensureMoltbotModelsJson(params.cfg, params.agentDir);
+    await ensureOpenClawModelsJson(params.cfg, params.agentDir);
     const authStorage = discoverAuthStorage(params.agentDir);
     const modelRegistry = discoverModels(authStorage, params.agentDir);
     const model = modelRegistry.find(params.provider, params.model);

package/dist/media-understanding/runner.js

@@ -769,7 +769,7 @@ async function runCliEntry(params) {
         maxBytes,
         timeoutMs,
     });
-    const outputDir = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-media-cli-"));
+    const outputDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-media-cli-"));
     const mediaPath = pathResult.path;
     const outputBase = path.join(outputDir, path.parse(mediaPath).name);
     const templCtx = {

package/dist/memory/batch-gemini.js

@@ -2,7 +2,7 @@ import { createSubsystemLogger } from "../logging/subsystem.js";
 import { isTruthyEnvValue } from "../infra/env.js";
 import { hashText } from "./internal.js";
 const GEMINI_BATCH_MAX_REQUESTS = 50000;
-const debugEmbeddings = isTruthyEnvValue(process.env.CLAWDBOT_DEBUG_MEMORY_EMBEDDINGS);
+const debugEmbeddings = isTruthyEnvValue(process.env.OPENCLAW_DEBUG_MEMORY_EMBEDDINGS);
 const log = createSubsystemLogger("memory/embeddings");
 const debugLog = (message, meta) => {
     if (!debugEmbeddings)
@@ -42,7 +42,7 @@ function splitGeminiBatchRequests(requests) {
     return groups;
 }
 function buildGeminiUploadBody(params) {
-    const boundary = `moltbot-${hashText(params.displayName)}`;
+    const boundary = `openclaw-${hashText(params.displayName)}`;
     const jsonPart = JSON.stringify({
         file: {
             displayName: params.displayName,

package/dist/memory/batch-openai.js

@@ -56,7 +56,7 @@ async function submitOpenAiBatch(params) {
                 endpoint: OPENAI_BATCH_ENDPOINT,
                 completion_window: OPENAI_BATCH_COMPLETION_WINDOW,
                 metadata: {
-                    source: "moltbot-memory",
+                    source: "openclaw-memory",
                     agent: params.agentId,
                 },
             }),

package/dist/memory/embeddings-gemini.js

@@ -3,7 +3,7 @@ import { isTruthyEnvValue } from "../infra/env.js";
 import { createSubsystemLogger } from "../logging/subsystem.js";
 const DEFAULT_GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
 export const DEFAULT_GEMINI_EMBEDDING_MODEL = "gemini-embedding-001";
-const debugEmbeddings = isTruthyEnvValue(process.env.CLAWDBOT_DEBUG_MEMORY_EMBEDDINGS);
+const debugEmbeddings = isTruthyEnvValue(process.env.OPENCLAW_DEBUG_MEMORY_EMBEDDINGS);
 const log = createSubsystemLogger("memory/embeddings");
 const debugLog = (message, meta) => {
     if (!debugEmbeddings)

package/dist/memory/embeddings.js

@@ -160,7 +160,7 @@ function formatLocalSetupError(err) {
         "To enable local embeddings:",
         "1) Use Node 22 LTS (recommended for installs/updates)",
         missing
-            ? "2) Reinstall Moltbot (this should install node-llama-cpp): npm i -g moltbot@latest"
+            ? "2) Reinstall OpenClaw (this should install node-llama-cpp): npm i -g openclaw@latest"
             : null,
         "3) If you use pnpm: pnpm approve-builds (select node-llama-cpp), then pnpm rebuild node-llama-cpp",
         'Or set agents.defaults.memorySearch.provider = "openai" (remote).',

package/dist/memory/internal.js

@@ -13,6 +13,15 @@ export function normalizeRelPath(value) {
     const trimmed = value.trim().replace(/^[./]+/, "");
     return trimmed.replace(/\\/g, "/");
 }
+export function normalizeExtraMemoryPaths(workspaceDir, extraPaths) {
+    if (!extraPaths?.length)
+        return [];
+    const resolved = extraPaths
+        .map((value) => value.trim())
+        .filter(Boolean)
+        .map((value) => path.isAbsolute(value) ? path.resolve(value) : path.resolve(workspaceDir, value));
+    return Array.from(new Set(resolved));
+}
 export function isMemoryPath(relPath) {
     const normalized = normalizeRelPath(relPath);
     if (!normalized)
@@ -21,19 +30,12 @@ export function isMemoryPath(relPath) {
         return true;
     return normalized.startsWith("memory/");
 }
-async function exists(filePath) {
-    try {
-        await fs.access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 async function walkDir(dir, files) {
     const entries = await fs.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
         const full = path.join(dir, entry.name);
+        if (entry.isSymbolicLink())
+            continue;
         if (entry.isDirectory()) {
             await walkDir(full, files);
             continue;
@@ -45,17 +47,48 @@ async function walkDir(dir, files) {
         files.push(full);
     }
 }
-export async function listMemoryFiles(workspaceDir) {
+export async function listMemoryFiles(workspaceDir, extraPaths) {
     const result = [];
     const memoryFile = path.join(workspaceDir, "MEMORY.md");
     const altMemoryFile = path.join(workspaceDir, "memory.md");
-    if (await exists(memoryFile))
-        result.push(memoryFile);
-    if (await exists(altMemoryFile))
-        result.push(altMemoryFile);
     const memoryDir = path.join(workspaceDir, "memory");
-    if (await exists(memoryDir)) {
-        await walkDir(memoryDir, result);
+    const addMarkdownFile = async (absPath) => {
+        try {
+            const stat = await fs.lstat(absPath);
+            if (stat.isSymbolicLink() || !stat.isFile())
+                return;
+            if (!absPath.endsWith(".md"))
+                return;
+            result.push(absPath);
+        }
+        catch { }
+    };
+    await addMarkdownFile(memoryFile);
+    await addMarkdownFile(altMemoryFile);
+    try {
+        const dirStat = await fs.lstat(memoryDir);
+        if (!dirStat.isSymbolicLink() && dirStat.isDirectory()) {
+            await walkDir(memoryDir, result);
+        }
+    }
+    catch { }
+    const normalizedExtraPaths = normalizeExtraMemoryPaths(workspaceDir, extraPaths);
+    if (normalizedExtraPaths.length > 0) {
+        for (const inputPath of normalizedExtraPaths) {
+            try {
+                const stat = await fs.lstat(inputPath);
+                if (stat.isSymbolicLink())
+                    continue;
+                if (stat.isDirectory()) {
+                    await walkDir(inputPath, result);
+                    continue;
+                }
+                if (stat.isFile() && inputPath.endsWith(".md")) {
+                    result.push(inputPath);
+                }
+            }
+            catch { }
+        }
     }
     if (result.length <= 1)
         return result;

package/dist/memory/manager-cache-key.js

@@ -5,6 +5,7 @@ export function computeMemoryManagerCacheKey(params) {
     const fingerprint = hashText(JSON.stringify({
         enabled: settings.enabled,
         sources: [...settings.sources].sort((a, b) => a.localeCompare(b)),
+        extraPaths: [...settings.extraPaths].sort((a, b) => a.localeCompare(b)),
         provider: settings.provider,
         model: settings.model,
         fallback: settings.fallback,

package/dist/memory/manager.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import chokidar from "chokidar";
@@ -13,7 +14,7 @@ import { DEFAULT_GEMINI_EMBEDDING_MODEL } from "./embeddings-gemini.js";
 import { DEFAULT_OPENAI_EMBEDDING_MODEL } from "./embeddings-openai.js";
 import { OPENAI_BATCH_ENDPOINT, runOpenAiEmbeddingBatches, } from "./batch-openai.js";
 import { runGeminiEmbeddingBatches } from "./batch-gemini.js";
-import { buildFileEntry, chunkMarkdown, ensureDir, hashText, isMemoryPath, listMemoryFiles, normalizeRelPath, parseEmbedding, } from "./internal.js";
+import { buildFileEntry, chunkMarkdown, ensureDir, hashText, isMemoryPath, listMemoryFiles, normalizeExtraMemoryPaths, parseEmbedding, } from "./internal.js";
 import { bm25RankToScore, buildFtsQuery, mergeHybridResults } from "./hybrid.js";
 import { searchKeyword, searchVector } from "./manager-search.js";
 import { ensureMemoryIndexSchema } from "./memory-schema.js";
@@ -257,13 +258,50 @@ export class MemoryIndexManager {
         return this.syncing;
     }
     async readFile(params) {
-        const relPath = normalizeRelPath(params.relPath);
-        if (!relPath || !isMemoryPath(relPath)) {
+        const rawPath = params.relPath.trim();
+        if (!rawPath) {
             throw new Error("path required");
         }
-        const absPath = path.resolve(this.workspaceDir, relPath);
-        if (!absPath.startsWith(this.workspaceDir)) {
-            throw new Error("path escapes workspace");
+        const absPath = path.isAbsolute(rawPath)
+            ? path.resolve(rawPath)
+            : path.resolve(this.workspaceDir, rawPath);
+        const relPath = path.relative(this.workspaceDir, absPath).replace(/\\/g, "/");
+        const inWorkspace = relPath.length > 0 && !relPath.startsWith("..") && !path.isAbsolute(relPath);
+        const allowedWorkspace = inWorkspace && isMemoryPath(relPath);
+        let allowedAdditional = false;
+        if (!allowedWorkspace && this.settings.extraPaths.length > 0) {
+            const additionalPaths = normalizeExtraMemoryPaths(this.workspaceDir, this.settings.extraPaths);
+            for (const additionalPath of additionalPaths) {
+                try {
+                    const stat = await fs.lstat(additionalPath);
+                    if (stat.isSymbolicLink())
+                        continue;
+                    if (stat.isDirectory()) {
+                        if (absPath === additionalPath || absPath.startsWith(`${additionalPath}${path.sep}`)) {
+                            allowedAdditional = true;
+                            break;
+                        }
+                        continue;
+                    }
+                    if (stat.isFile()) {
+                        if (absPath === additionalPath && absPath.endsWith(".md")) {
+                            allowedAdditional = true;
+                            break;
+                        }
+                    }
+                }
+                catch { }
+            }
+        }
+        if (!allowedWorkspace && !allowedAdditional) {
+            throw new Error("path required");
+        }
+        if (!absPath.endsWith(".md")) {
+            throw new Error("path required");
+        }
+        const stat = await fs.lstat(absPath);
+        if (stat.isSymbolicLink() || !stat.isFile()) {
+            throw new Error("path required");
         }
         const content = await fs.readFile(absPath, "utf-8");
         if (!params.from && !params.lines) {
@@ -319,6 +357,7 @@ export class MemoryIndexManager {
             model: this.provider.model,
             requestedProvider: this.requestedProvider,
             sources: Array.from(this.sources),
+            extraPaths: this.settings.extraPaths,
             sourceCounts,
             cache: this.cache.enabled
                 ? {
@@ -561,11 +600,24 @@ export class MemoryIndexManager {
     ensureWatcher() {
         if (!this.sources.has("memory") || !this.settings.sync.watch || this.watcher)
             return;
-        const watchPaths = [
+        const additionalPaths = normalizeExtraMemoryPaths(this.workspaceDir, this.settings.extraPaths)
+            .map((entry) => {
+            try {
+                const stat = fsSync.lstatSync(entry);
+                return stat.isSymbolicLink() ? null : entry;
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((entry) => Boolean(entry));
+        const watchPaths = new Set([
             path.join(this.workspaceDir, "MEMORY.md"),
+            path.join(this.workspaceDir, "memory.md"),
             path.join(this.workspaceDir, "memory"),
-        ];
-        this.watcher = chokidar.watch(watchPaths, {
+            ...additionalPaths,
+        ]);
+        this.watcher = chokidar.watch(Array.from(watchPaths), {
             ignoreInitial: true,
             awaitWriteFinish: {
                 stabilityThreshold: this.settings.sync.watchDebounceMs,
@@ -764,7 +816,7 @@ export class MemoryIndexManager {
         return this.sessionsDirty && this.sessionsDirtyFiles.size > 0;
     }
     async syncMemoryFiles(params) {
-        const files = await listMemoryFiles(this.workspaceDir);
+        const files = await listMemoryFiles(this.workspaceDir, this.settings.extraPaths);
         const fileEntries = await Promise.all(files.map(async (file) => buildFileEntry(file, this.workspaceDir)));
         log.debug("memory sync: indexing memory files", {
             files: fileEntries.length,

package/dist/memory/sync-memory-files.js

@@ -2,7 +2,7 @@ import { createSubsystemLogger } from "../logging/subsystem.js";
 import { buildFileEntry, listMemoryFiles } from "./internal.js";
 const log = createSubsystemLogger("memory");
 export async function syncMemoryFiles(params) {
-    const files = await listMemoryFiles(params.workspaceDir);
+    const files = await listMemoryFiles(params.workspaceDir, params.extraPaths);
     const fileEntries = await Promise.all(files.map(async (file) => buildFileEntry(file, params.workspaceDir)));
     log.debug("memory sync: indexing memory files", {
         files: fileEntries.length,

package/dist/node-host/runner.js

@@ -13,7 +13,7 @@ import { createBrowserControlContext, startBrowserControlServiceFromConfig, } fr
 import { createBrowserRouteDispatcher } from "../browser/routes/dispatcher.js";
 import { detectMime } from "../media/mime.js";
 import { resolveAgentConfig } from "../agents/agent-scope.js";
-import { ensureMoltbotCliOnPath } from "../infra/path-env.js";
+import { ensureOpenClawCliOnPath } from "../infra/path-env.js";
 import { VERSION } from "../version.js";
 import { GATEWAY_CLIENT_MODES, GATEWAY_CLIENT_NAMES } from "../utils/message-channel.js";
 import { ensureNodeHostConfig, saveNodeHostConfig } from "./config.js";
@@ -28,8 +28,8 @@ const OUTPUT_CAP = 200_000;
 const OUTPUT_EVENT_TAIL = 20_000;
 const DEFAULT_NODE_PATH = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
 const BROWSER_PROXY_MAX_FILE_BYTES = 10 * 1024 * 1024;
-const execHostEnforced = process.env.CLAWDBOT_NODE_EXEC_HOST?.trim().toLowerCase() === "app";
-const execHostFallbackAllowed = process.env.CLAWDBOT_NODE_EXEC_FALLBACK?.trim().toLowerCase() !== "0";
+const execHostEnforced = process.env.OPENCLAW_NODE_EXEC_HOST?.trim().toLowerCase() === "app";
+const execHostFallbackAllowed = process.env.OPENCLAW_NODE_EXEC_FALLBACK?.trim().toLowerCase() !== "0";
 const blockedEnvKeys = new Set([
     "NODE_OPTIONS",
     "PYTHONHOME",
@@ -296,7 +296,7 @@ function resolveEnvPath(env) {
     return raw.split(path.delimiter).filter(Boolean);
 }
 function ensureNodePathEnv() {
-    ensureMoltbotCliOnPath({ pathEnv: process.env.PATH ?? "" });
+    ensureOpenClawCliOnPath({ pathEnv: process.env.PATH ?? "" });
     const current = process.env.PATH ?? "";
     if (current.trim())
         return current;
@@ -368,9 +368,9 @@ export async function runNodeHost(opts) {
     const resolvedBrowser = resolveBrowserConfig(cfg.browser, cfg);
     const browserProxyEnabled = browserProxy.enabled && resolvedBrowser.enabled;
     const isRemoteMode = cfg.gateway?.mode === "remote";
-    const token = process.env.CLAWDBOT_GATEWAY_TOKEN?.trim() ||
+    const token = process.env.OPENCLAW_GATEWAY_TOKEN?.trim() ||
         (isRemoteMode ? cfg.gateway?.remote?.token : cfg.gateway?.auth?.token);
-    const password = process.env.CLAWDBOT_GATEWAY_PASSWORD?.trim() ||
+    const password = process.env.OPENCLAW_GATEWAY_PASSWORD?.trim() ||
         (isRemoteMode ? cfg.gateway?.remote?.password : cfg.gateway?.auth?.password);
     const host = gateway.host ?? "127.0.0.1";
     const port = gateway.port ?? 18789;