dominds 1.25.0 → 1.25.2

package/dist/tools/fs.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rmSymlinkTool = exports.createSymlinkTool = exports.readSymlinkTool = exports.moveDirTool = exports.moveFileTool = exports.mkDirTool = exports.rmFileTool = exports.rmDirTool = exports.listDirTool = void 0;
+exports.rmSymlinkTool = exports.createSymlinkTool = exports.fsReadSymlinkTool = exports.readSymlinkTool = exports.moveDirTool = exports.moveFileTool = exports.mkDirTool = exports.rmFileTool = exports.rmDirTool = exports.fsListDirTool = exports.listDirTool = void 0;
 /**
  * Module: tools/fs
  *
@@ -337,7 +337,7 @@ exports.listDirTool = {
                             : entry.type === 'symlink'
                                 ? '🔗'
                                 : '❓';
-                    const sizeStr = entry.size ? formatSize(entry.size) : '-';
+                    const sizeStr = entry.size === undefined ? '-' : formatSize(entry.size);
                     const linesStr = entry.lines ? entry.lines.toString() : '-';
                     const targetTypeStr = entry.type === 'symlink' && entry.symlinkResolvedType
                         ? ` (${entry.symlinkResolvedType})`
@@ -369,6 +369,220 @@ exports.listDirTool = {
         }
     },
 };
+exports.fsListDirTool = {
+    type: 'func',
+    name: 'fs_list_dir',
+    description: 'List local filesystem directory contents without restricting paths to rtws (runtime workspace).',
+    descriptionI18n: {
+        en: 'List local filesystem directory contents without restricting paths to rtws (runtime workspace).',
+        zh: '列出本机文件系统目录内容，不限制路径必须位于 rtws（运行时工作区）内。',
+    },
+    parameters: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            path: {
+                type: 'string',
+                description: "Directory path to read. Absolute paths are accepted; relative paths resolve from the current process cwd. Defaults to '.'.",
+            },
+        },
+    },
+    argsValidation: 'dominds',
+    call: async (_dlg, _caller, args) => {
+        const workLanguage = (0, work_language_1.getWorkLanguage)();
+        const labels = workLanguage === 'zh'
+            ? {
+                notFound: (p) => `❌ **未找到**\n\n目录 \`${p}\` 不存在。`,
+                notDir: (p) => `❌ **错误**\n\n路径 \`${p}\` 不是目录。`,
+                readDirFailed: (msg) => `❌ **错误**\n\n读取目录失败：${msg}`,
+                dirHeader: '📁 **目录：**',
+                symlinkPathNotice: (p, target) => target
+                    ? `🔗 **说明：** \`${p}\` 是符号链接（→ \`${target}\`），已按目录跟随读取。`
+                    : `🔗 **说明：** \`${p}\` 是符号链接，已按目录跟随读取。`,
+                emptyDir: '_此目录为空。_',
+                table: {
+                    name: '名称',
+                    type: '类型',
+                    size: '大小',
+                    lines: '行数',
+                    target: '目标',
+                },
+            }
+            : {
+                notFound: (p) => `❌ **Not Found**\n\nDirectory \`${p}\` does not exist.`,
+                notDir: (p) => `❌ **Error**\n\nPath \`${p}\` is not a directory.`,
+                readDirFailed: (msg) => `❌ **Error**\n\nFailed to read directory: ${msg}`,
+                dirHeader: '📁 **Directory:**',
+                symlinkPathNotice: (p, target) => target
+                    ? `🔗 **Note:** \`${p}\` is a symlink (→ \`${target}\`), and was followed as a directory.`
+                    : `🔗 **Note:** \`${p}\` is a symlink and was followed as a directory.`,
+                emptyDir: '_This directory is empty._',
+                table: {
+                    name: 'Name',
+                    type: 'Type',
+                    size: 'Size',
+                    lines: 'Lines',
+                    target: 'Target',
+                },
+            };
+        let requestedPath = '.';
+        const pathValue = args['path'];
+        if (typeof pathValue === 'string' && pathValue.trim() !== '') {
+            requestedPath = pathValue.trim();
+        }
+        const dir = path_1.default.resolve(process.cwd(), requestedPath);
+        const displayPath = path_1.default.isAbsolute(requestedPath) ? dir : requestedPath;
+        try {
+            let inputPathIsSymlink = false;
+            let inputPathSymlinkTarget;
+            try {
+                const statsInfo = await statWithSymlinkInfo(dir);
+                inputPathIsSymlink = statsInfo.isSymlink;
+                inputPathSymlinkTarget = statsInfo.symlinkTarget;
+                if (!statsInfo.followStat.isDirectory()) {
+                    return fail(labels.notDir(displayPath));
+                }
+            }
+            catch (error) {
+                if (typeof error === 'object' &&
+                    error !== null &&
+                    'code' in error &&
+                    error.code === 'ENOENT') {
+                    return fail(labels.notFound(displayPath));
+                }
+                const msg = error instanceof Error ? error.message : String(error);
+                return fail(labels.readDirFailed(msg));
+            }
+            const entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+            const data = [];
+            for (const entry of entries) {
+                const entryPath = path_1.default.join(dir, entry.name);
+                const dirEntry = {
+                    name: entry.name,
+                    type: 'other',
+                };
+                try {
+                    const stats = await promises_1.default.lstat(entryPath);
+                    if (entry.isDirectory()) {
+                        dirEntry.type = 'dir';
+                        dirEntry.size = stats.size;
+                    }
+                    else if (entry.isFile()) {
+                        dirEntry.type = 'file';
+                        dirEntry.size = stats.size;
+                        if (isTextFile(entry.name)) {
+                            dirEntry.lines = await countLines(entryPath);
+                        }
+                    }
+                    else if (entry.isSymbolicLink()) {
+                        dirEntry.type = 'symlink';
+                        dirEntry.size = stats.size;
+                        try {
+                            const target = await promises_1.default.readlink(entryPath);
+                            dirEntry.target = target;
+                            try {
+                                const targetStats = await promises_1.default.stat(entryPath);
+                                if (targetStats.isDirectory()) {
+                                    dirEntry.symlinkResolvedType = 'dir';
+                                }
+                                else if (targetStats.isFile()) {
+                                    dirEntry.symlinkResolvedType = 'file';
+                                }
+                                else {
+                                    dirEntry.symlinkResolvedType = 'other';
+                                }
+                                if (targetStats.isFile() && (isTextFile(entry.name) || isTextFile(target))) {
+                                    dirEntry.lines = await countLines(entryPath);
+                                }
+                            }
+                            catch (err) {
+                                log_1.log.warn(`Failed to stat symlink target ${entryPath}:`, err);
+                                dirEntry.symlinkResolvedType = 'broken';
+                            }
+                        }
+                        catch (err) {
+                            log_1.log.warn(`Failed to read symlink ${entryPath}:`, err);
+                            dirEntry.target = '<unreadable>';
+                            dirEntry.symlinkResolvedType = 'other';
+                        }
+                    }
+                    else {
+                        dirEntry.type = 'other';
+                        dirEntry.size = stats.size;
+                    }
+                }
+                catch (_error) {
+                    if (entry.isDirectory()) {
+                        dirEntry.type = 'dir';
+                    }
+                    else if (entry.isFile()) {
+                        dirEntry.type = 'file';
+                    }
+                    else if (entry.isSymbolicLink()) {
+                        dirEntry.type = 'symlink';
+                        dirEntry.target = '<error>';
+                    }
+                }
+                data.push(dirEntry);
+            }
+            let markdown = `${labels.dirHeader} \`${displayPath}\`\n\n`;
+            if (inputPathIsSymlink) {
+                markdown += `${labels.symlinkPathNotice(displayPath, inputPathSymlinkTarget)}\n\n`;
+            }
+            if (data.length === 0) {
+                markdown += labels.emptyDir;
+            }
+            else {
+                const shownEntries = data.slice(0, LIST_DIR_MAX_RENDERED_ENTRIES);
+                const omittedEntries = Math.max(0, data.length - shownEntries.length);
+                if (omittedEntries > 0) {
+                    markdown +=
+                        workLanguage === 'zh'
+                            ? `⚠️ **说明：** 目录项过多；为避免输出过长，仅展示前 ${shownEntries.length} 项，省略 ${omittedEntries} 项。\n\n`
+                            : `⚠️ **Note:** Directory contains many entries; to keep the output bounded, showing the first ${shownEntries.length} entries and omitting ${omittedEntries}.\n\n`;
+                }
+                markdown += `| ${labels.table.name} | ${labels.table.type} | ${labels.table.size} | ${labels.table.lines} | ${labels.table.target} |\n`;
+                markdown += '|------|------|------|-------|--------|\n';
+                for (const entry of shownEntries) {
+                    const typeIcon = entry.type === 'dir'
+                        ? '📁'
+                        : entry.type === 'file'
+                            ? '📄'
+                            : entry.type === 'symlink'
+                                ? '🔗'
+                                : '❓';
+                    const sizeStr = entry.size === undefined ? '-' : formatSize(entry.size);
+                    const linesStr = entry.lines ? entry.lines.toString() : '-';
+                    const targetTypeStr = entry.type === 'symlink' && entry.symlinkResolvedType
+                        ? ` (${entry.symlinkResolvedType})`
+                        : '';
+                    const renderedName = (0, output_limit_1.truncateInlineText)(entry.name, LIST_DIR_NAME_CHAR_LIMIT);
+                    const targetStr = entry.target
+                        ? (0, output_limit_1.truncateInlineText)(`→ ${entry.target}${targetTypeStr}`, LIST_DIR_TARGET_CHAR_LIMIT)
+                        : '-';
+                    markdown += `| ${typeIcon} \`${renderedName}\` | ${entry.type} | ${sizeStr} | ${linesStr} | ${targetStr} |\n`;
+                }
+            }
+            return ok(markdown);
+        }
+        catch (error) {
+            if (typeof error === 'object' &&
+                error !== null &&
+                'code' in error &&
+                error.code === 'ENOENT') {
+                return fail(labels.notFound(displayPath));
+            }
+            if (typeof error === 'object' &&
+                error !== null &&
+                'code' in error &&
+                error.code === 'ENOTDIR') {
+                return fail(labels.notDir(displayPath));
+            }
+            const msg = error instanceof Error ? error.message : String(error);
+            return fail(labels.readDirFailed(msg));
+        }
+    },
+};
 exports.rmDirTool = {
     type: 'func',
     name: 'rm_dir',
@@ -1045,6 +1259,71 @@ exports.readSymlinkTool = {
         }
     },
 };
+exports.fsReadSymlinkTool = {
+    type: 'func',
+    name: 'fs_read_symlink',
+    description: 'Read a local filesystem symlink target without following it, without restricting paths to rtws.',
+    descriptionI18n: {
+        en: 'Read a local filesystem symlink target without following it, without restricting paths to rtws.',
+        zh: '读取本机文件系统符号链接目标（不跟随链接），不限制路径必须位于 rtws 内。',
+    },
+    parameters: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['path'],
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Symlink path. Absolute paths are accepted; relative paths resolve from the current process cwd.',
+            },
+        },
+    },
+    argsValidation: 'dominds',
+    call: async (_dlg, _caller, args) => {
+        const pathValue = args['path'];
+        const requestedPath = typeof pathValue === 'string' ? pathValue.trim() : '';
+        if (!requestedPath) {
+            return failYaml([
+                `status: error`,
+                `mode: fs_read_symlink`,
+                `error: PATH_REQUIRED`,
+                `summary: ${yamlQuote('Fs-read-symlink failed: path required.')}`,
+            ].join('\n'));
+        }
+        const absPath = path_1.default.resolve(process.cwd(), requestedPath);
+        const displayPath = path_1.default.isAbsolute(requestedPath) ? absPath : requestedPath;
+        try {
+            const pathStat = await promises_1.default.lstat(absPath);
+            if (!pathStat.isSymbolicLink()) {
+                return failYaml([
+                    `status: error`,
+                    `mode: fs_read_symlink`,
+                    `path: ${yamlQuote(displayPath)}`,
+                    `error: NOT_SYMLINK`,
+                    `summary: ${yamlQuote('Fs-read-symlink failed: path is not a symlink.')}`,
+                ].join('\n'));
+            }
+            const target = await promises_1.default.readlink(absPath);
+            return okYaml([
+                `status: ok`,
+                `mode: fs_read_symlink`,
+                `path: ${yamlQuote(displayPath)}`,
+                `target: ${yamlQuote(target)}`,
+                `summary: ${yamlQuote(`Fs-read-symlink: ${displayPath} -> ${target}.`)}`,
+            ].join('\n'));
+        }
+        catch (error) {
+            const yaml = [
+                `status: error`,
+                `mode: fs_read_symlink`,
+                `path: ${yamlQuote(displayPath)}`,
+                `error: FAILED`,
+                `summary: ${yamlQuote(error instanceof Error ? error.message : String(error))}`,
+            ].join('\n');
+            return failYaml(yaml);
+        }
+    },
+};
 exports.createSymlinkTool = {
     type: 'func',
     name: 'create_symlink',

package/dist/tools/os.d.ts

@@ -6,8 +6,19 @@
  */
 import type { FuncTool, ReminderOwner } from '../tool';
 export declare function resetTrackedDaemonsForTests(): void;
+type ShellSpawnSpec = Readonly<{
+    command: string;
+    args: string[];
+    shellLabel: string;
+}>;
+export declare function resolveShellCmdSpawnSpecForTests(command: string, shell: string | undefined, platform: NodeJS.Platform): ShellSpawnSpec;
+export declare function resolveReadonlyShellSpawnSpecForTests(command: string, platform: NodeJS.Platform): Readonly<{
+    command: string;
+    args: string[];
+}>;
 export declare const shellCmdReminderOwner: ReminderOwner;
 export declare const shellCmdTool: FuncTool;
 export declare const readonlyShellTool: FuncTool;
 export declare const stopDaemonTool: FuncTool;
 export declare const getDaemonOutputTool: FuncTool;
+export {};

package/dist/tools/os.js

@@ -11,6 +11,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDaemonOutputTool = exports.stopDaemonTool = exports.readonlyShellTool = exports.shellCmdTool = exports.shellCmdReminderOwner = void 0;
 exports.resetTrackedDaemonsForTests = resetTrackedDaemonsForTests;
+exports.resolveShellCmdSpawnSpecForTests = resolveShellCmdSpawnSpecForTests;
+exports.resolveReadonlyShellSpawnSpecForTests = resolveReadonlyShellSpawnSpecForTests;
 const time_1 = require("@longrun-ai/kernel/utils/time");
 const child_process_1 = require("child_process");
 const crypto_1 = __importDefault(require("crypto"));
@@ -278,7 +280,7 @@ async function ensureTrackedDaemonForAgent(agentId, pid) {
     if (existing) {
         return existing;
     }
-    const reminders = await (0, shared_reminders_1.loadAgentSharedReminders)(agentId);
+    const reminders = await (0, shared_reminders_1.loadSharedReminders)({ kind: 'agent', agentId });
     for (const reminder of reminders) {
         if (isShellCmdReminder(reminder) && reminder.meta.pid === pid) {
             return await ensureTrackedDaemonFromReminder(reminder);
@@ -679,7 +681,7 @@ async function removeDaemonRemindersForPid(dlg, pid) {
     for (let i = indicesToRemove.length - 1; i >= 0; i--) {
         dlg.deleteReminder(indicesToRemove[i]);
     }
-    await (0, shared_reminders_1.mutateAgentSharedReminders)(dlg.agentId, (reminders) => {
+    await (0, shared_reminders_1.mutateSharedReminders)({ kind: 'agent', agentId: dlg.agentId }, (reminders) => {
         for (let i = reminders.length - 1; i >= 0; i--) {
             const reminder = reminders[i];
             if (isShellCmdReminder(reminder) && reminder.meta.pid === pid) {
@@ -816,9 +818,12 @@ function parseGetDaemonOutputArgs(args) {
     }
     return { pid, stdout, stderr };
 }
-function resolveShellCmdSpawnSpec(command, shell) {
+function encodePowerShellCommand(command) {
+    return Buffer.from(command, 'utf16le').toString('base64');
+}
+function resolveShellCmdSpawnSpec(command, shell, platform = process.platform) {
     const preferredShell = typeof shell === 'string' && shell.trim() !== '' ? shell.trim() : undefined;
-    if (process.platform === 'win32') {
+    if (platform === 'win32') {
         if (preferredShell) {
             const base = path_1.default.basename(preferredShell).toLowerCase();
             if (base === 'powershell' ||
@@ -827,14 +832,14 @@ function resolveShellCmdSpawnSpec(command, shell) {
                 base === 'pwsh.exe') {
                 return {
                     command: preferredShell,
-                    args: ['-NoLogo', '-NoProfile', '-Command', command],
+                    args: ['-NoLogo', '-NoProfile', '-EncodedCommand', encodePowerShellCommand(command)],
                     shellLabel: preferredShell,
                 };
             }
             if (base === 'cmd' || base === 'cmd.exe') {
                 return {
                     command: preferredShell,
-                    args: ['/d', '/s', '/c', command],
+                    args: ['/d', '/c', command],
                     shellLabel: preferredShell,
                 };
             }
@@ -846,7 +851,7 @@ function resolveShellCmdSpawnSpec(command, shell) {
         }
         return {
             command: 'cmd.exe',
-            args: ['/d', '/s', '/c', command],
+            args: ['/d', '/c', command],
             shellLabel: 'cmd.exe',
         };
     }
@@ -857,12 +862,18 @@ function resolveShellCmdSpawnSpec(command, shell) {
         shellLabel: resolvedShell,
     };
 }
-function resolveReadonlyShellSpawnSpec(command) {
-    if (process.platform === 'win32') {
-        return { command: 'cmd.exe', args: ['/d', '/s', '/c', command] };
+function resolveShellCmdSpawnSpecForTests(command, shell, platform) {
+    return resolveShellCmdSpawnSpec(command, shell, platform);
+}
+function resolveReadonlyShellSpawnSpec(command, platform = process.platform) {
+    if (platform === 'win32') {
+        return { command: 'cmd.exe', args: ['/d', '/c', command] };
     }
     return { command: 'bash', args: ['-c', command] };
 }
+function resolveReadonlyShellSpawnSpecForTests(command, platform) {
+    return resolveReadonlyShellSpawnSpec(command, platform);
+}
 function resolveCmdRunnerEntrypointAbs() {
     const distCandidate = path_1.default.resolve(__dirname, 'cmd-runner.js');
     if (fs_1.default.existsSync(distCandidate)) {
@@ -1105,7 +1116,7 @@ const shellCmdSchema = {
         },
         shell: {
             type: 'string',
-            description: 'Shell to use for execution (default: bash on Linux/macOS; cmd.exe on Windows)',
+            description: 'Shell to use for execution (default: bash on Linux/macOS; cmd.exe on Windows). On Windows, powershell.exe/pwsh commands are passed via -EncodedCommand.',
         },
         scrollbackLines: {
             type: 'number',
@@ -1523,11 +1534,11 @@ exports.shellCmdTool = {
                 content: `[Daemon PID ${initialMessage.daemonPid} - This content should not be visible, check dynamic rendering]`,
                 owner: exports.shellCmdReminderOwner,
                 meta: reminderMeta,
-                scope: 'agent_shared',
+                scope: 'runtime',
                 renderMode: 'markdown',
             });
             try {
-                await (0, shared_reminders_1.mutateAgentSharedReminders)(dlg.agentId, (reminders) => {
+                await (0, shared_reminders_1.mutateSharedReminders)({ kind: 'agent', agentId: dlg.agentId }, (reminders) => {
                     reminders.push(reminder);
                 });
                 dlg.touchReminders();
@@ -2252,7 +2263,7 @@ exports.stopDaemonTool = {
         const language = (0, work_language_1.getWorkLanguage)();
         const t = getOsToolMessages(language);
         const { pid, entirePg } = parseStopDaemonArgs(args);
-        const reminders = await (0, shared_reminders_1.loadAgentSharedReminders)(dlg.agentId);
+        const reminders = await (0, shared_reminders_1.loadSharedReminders)({ kind: 'agent', agentId: dlg.agentId });
         const reminder = reminders.find((candidate) => isShellCmdReminder(candidate) && candidate.meta.pid === pid);
         if (!reminder || !isShellCmdReminder(reminder)) {
             return (0, tool_1.toolFailure)(t.noDaemonFound(pid));
@@ -2309,7 +2320,7 @@ exports.getDaemonOutputTool = {
         const language = (0, work_language_1.getWorkLanguage)();
         const t = getOsToolMessages(language);
         const { pid, stdout, stderr } = parseGetDaemonOutputArgs(args);
-        const reminders = await (0, shared_reminders_1.loadAgentSharedReminders)(dlg.agentId);
+        const reminders = await (0, shared_reminders_1.loadSharedReminders)({ kind: 'agent', agentId: dlg.agentId });
         const reminder = reminders.find((candidate) => isShellCmdReminder(candidate) && candidate.meta.pid === pid);
         if (!reminder || !isShellCmdReminder(reminder)) {
             return (0, tool_1.toolFailure)(t.noDaemonFound(pid));

package/dist/tools/picture.d.ts

@@ -1,3 +1,4 @@
 import type { FuncTool } from '../tool';
 export declare const readPictureTool: FuncTool;
+export declare const fsReadPictureTool: FuncTool;
 export declare const writePictureTool: FuncTool;

package/dist/tools/picture.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writePictureTool = exports.readPictureTool = void 0;
+exports.writePictureTool = exports.fsReadPictureTool = exports.readPictureTool = void 0;
 const crypto_1 = require("crypto");
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
@@ -33,6 +33,12 @@ function ensureInsideWorkspace(rel) {
     }
     throw new Error('Path must be within rtws (runtime workspace)');
 }
+function resolveLocalFilesystemPath(inputPath) {
+    return path_1.default.resolve(process.cwd(), inputPath);
+}
+function displayLocalFilesystemPath(inputPath, absPath) {
+    return path_1.default.isAbsolute(inputPath) ? absPath : inputPath;
+}
 function requirePathArg(args) {
     const value = args['path'];
     if (typeof value !== 'string' || value.trim() === '') {
@@ -246,6 +252,63 @@ exports.readPictureTool = {
         }
     },
 };
+exports.fsReadPictureTool = {
+    type: 'func',
+    name: 'fs_read_picture',
+    description: 'Read a PNG/JPEG/WebP/GIF image from the local filesystem without restricting paths to rtws, then attach it as an image content item for the next LLM context.',
+    descriptionI18n: {
+        en: 'Read a PNG/JPEG/WebP/GIF image from the local filesystem without restricting paths to rtws, then attach it as an image content item for the next LLM context.',
+        zh: '读取本机文件系统中的 PNG/JPEG/WebP/GIF 图片（不限制路径必须位于 rtws 内），并作为图片 content item 放入后续 LLM 上下文。',
+    },
+    parameters: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Image path to read. Absolute paths are accepted; relative paths resolve from the current process cwd. Supported extensions: .png, .jpg, .jpeg, .webp, .gif.',
+            },
+        },
+        required: ['path'],
+    },
+    argsValidation: 'dominds',
+    call: async (dlg, _caller, args) => {
+        try {
+            const requestedPath = requirePathArg(args);
+            const absPath = resolveLocalFilesystemPath(requestedPath);
+            const displayPath = displayLocalFilesystemPath(requestedPath, absPath);
+            const mimeType = extToMimeType(displayPath);
+            if (mimeType === null) {
+                return fail('Unsupported image extension. Supported extensions: .png, .jpg, .jpeg, .webp, .gif');
+            }
+            const stat = await promises_1.default.stat(absPath);
+            if (!stat.isFile())
+                return fail(`Path is not a file: ${displayPath}`);
+            if (stat.size <= 0 || stat.size > PICTURE_MAX_BYTES) {
+                return fail(`Image must be between 1 byte and ${String(PICTURE_MAX_BYTES)} bytes`);
+            }
+            const bytes = await promises_1.default.readFile(absPath);
+            validateImageBytesMatchMimeType(bytes, mimeType);
+            const item = await persistPictureArtifact({
+                dlg,
+                toolName: 'fs_read_picture',
+                mimeType,
+                bytes,
+            });
+            return ok(formatPictureResultYaml({
+                status: 'ok',
+                action: 'fs_read_picture',
+                path: displayPath,
+                mimeType,
+                byteLength: bytes.length,
+                artifactRelPath: item.artifact.relPath,
+            }), [item]);
+        }
+        catch (error) {
+            return fail(error instanceof Error ? error.message : String(error));
+        }
+    },
+};
 exports.writePictureTool = {
     type: 'func',
     name: 'write_picture',

package/dist/tools/prompts/codex_inspect_and_patch_tools/en/tools.md

@@ -12,6 +12,11 @@ Typical uses:
 - read-only `git status` / `git diff` / `git log` / `git show`
 - version probes and simple filesystem inspection
 
+Windows notes:
+
+- Prefer no-space forward-slash paths such as `D:/path/to/file`
+- Avoid nested `cmd /c "..."`
+
 Example:
 
 ```typescript

package/dist/tools/prompts/codex_inspect_and_patch_tools/zh/tools.md

@@ -12,6 +12,11 @@
 - 只读 `git status` / `git diff` / `git log` / `git show`
 - 版本探针与简单文件系统检查
 
+Windows 注意：
+
+- 优先使用不带空格的正斜杠路径，如 `D:/path/to/file`
+- 避免嵌套 `cmd /c "..."`
+
 示例：
 
 ```typescript

package/dist/tools/prompts/control/en/errors.md

@@ -26,20 +26,6 @@
 - Use the correct reminder id
 - First use `add_reminder` to create a reminder
 
-### REMINDER_INVALID_POSITION
-
-**Description:** Reminder position is invalid.
-
-**Cause:**
-
-- Position is out of valid range
-- Position format is incorrect
-
-**Solution:**
-
-- Ensure position is between 1 and current reminder count
-- By default, not specifying position will append to the end
-
 ### TASKDOC_CATEGORY_INVALID
 
 **Description:** Taskdoc category is invalid.
@@ -85,13 +71,13 @@
 
 ## Frequently Asked Questions
 
-### Q: What's the difference between dialog reminders, personal reminders, and memory?
+### Q: What's the difference between dialog, task, agent reminders, and memory?
 
-A: `dialog` reminders are only for the current dialog's working set. `personal` reminders stay visible in all later dialogs you lead, but still belong to the working set rather than long-term knowledge. `personal_memory` is for durable facts and reusable knowledge saved to disk; if the information should synchronize the team's current effective state, key decisions, next step, or still-active blockers, write it to Taskdoc `progress` instead of a reminder.
+A: `dialog` reminders are only for the current dialog's current work. `task` reminders are for current work under the same Taskdoc and are the default for `add_reminder`. `agent` reminders stay visible in all later dialogs you lead, but only for urgent, short-lived, globally visible cues. None of them are long-term knowledge. `personal_memory` is for durable facts and reusable knowledge saved to disk; if the information should synchronize the team's current effective state, key decisions, next step, or still-active blockers, write it to Taskdoc `progress` instead of a reminder.
 
-### Q: How do I choose `personal` vs `dialog`?
+### Q: How do I choose `dialog`, `task`, and `agent`?
 
-A: Use `personal` only for responsibility-related reminders that you should keep seeing in all later dialogs you lead. Everything else should default to `dialog`.
+A: Default to `task` so the reminder remains visible when continuing the same Taskdoc in a new dialog. Use `dialog` only for truly dialog-local notes; use `agent` only for urgent, short-lived, globally visible cues.
 
 ### Q: Do do_mind / mind_more / change_mind / never_mind start a new course?
 
@@ -111,4 +97,4 @@ A: There's no strict limit, but it's recommended to keep the number of reminders
 
 ### Q: How do I view all current reminders?
 
-A: The agent can access all visible reminders by `reminder_id` during response generation. That includes current-dialog reminders plus any visible personal/shared reminders available to you.
+A: The agent can access all visible reminders by `reminder_id` during response generation. That includes current-dialog reminders plus any visible task/agent/system reminders available to you.

package/dist/tools/prompts/control/en/index.md

@@ -26,7 +26,7 @@
 
 control is Dominds' **dialog control toolset** for managing dialog state, reminders, taskdocs, and inter-dialog reply closure semantics:
 
-- **Reminder management**: Two reminder scopes. Default to dialog-local working set; use `personal` only for responsibility-linked notes that you should keep seeing in all later dialogs you lead
+- **Reminder management**: Three reminder scopes: `dialog` / `task` / `agent`. Default to `task` for current work under the same Taskdoc; use `dialog` only for truly dialog-local notes; use `agent` only for urgent, short-lived, globally visible cues
 - **Taskdoc operations**: Append to, replace, or delete task contract sections (goals/constraints/progress); within Taskdoc, `progress` is the team-shared, quasi-real-time, scannable task bulletin board
 - **Context maintenance**: Reduce cognitive load without losing key resume state
 - **Reply routing**: Separate `tellaskBack`, `replyTellask*`, and plain text by responsibility in Side Dialog / ask-back flows
@@ -51,7 +51,7 @@ control is Dominds' **dialog control toolset** for managing dialog state, remind
 
 ### Reminder
 
-Reminders are temporary working-set information for:
+Reminders are temporary current-work information for:
 
 - Marking pending tasks
 - Tracking current next steps / blockers
@@ -62,8 +62,9 @@ Reminders are not for manually copying Dominds runtime-maintained environment st
 
 Scope rule:
 
-- `dialog`: current-dialog working set
-- `personal`: responsibility-related reminders that you should keep seeing in all later dialogs you lead
+- `dialog`: current-dialog current work
+- `task`: current work under the current Taskdoc, and the default scope
+- `agent`: urgent, short-lived, globally visible cues you should keep seeing in all later dialogs you lead
 
 ### Taskdoc