agent-sin 0.1.11 → 0.1.15

package/dist/discord/bot.js

@@ -3,10 +3,11 @@ import path from "node:path";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { loadConfig, loadModels } from "../core/config.js";
 import { appendEventLog } from "../core/logger.js";
-import { createIntentRuntime, renderBuildFooter, shouldShowBuildFooter, } from "../builder/build-flow.js";
+import { createIntentRuntime, enterEditModeForSkill, parseSlashBuildDirect, renderBuildFooter, shouldShowBuildFooter, } from "../builder/build-flow.js";
 import { routeConversationMessage, } from "../builder/conversation-router.js";
 import { formatBuildProgress, progressIntervalMs } from "../builder/progress-format.js";
 import { chunkText, cleanAttachmentText, formatAttachmentLabel, formatBytes, guessImageMimeType as guessImageMimeTypeFromName, indentAttachmentContent, isImageLikeFile, isTextLikeFile, } from "../core/message-utils.js";
+import { collectLocalFileAttachments, collectLocalImageAttachments, } from "../core/image-attachments.js";
 import { isEmptyIntentRuntime, loadIntentRuntimeMap, saveIntentRuntimeMap, } from "../builder/intent-runtime-store.js";
 import { inferLocaleFromText, l, lLines, withLocale } from "../core/i18n.js";
 import { modelsLines, skillsLines } from "../core/info-lines.js";
@@ -106,6 +107,7 @@ export async function runDiscordBot(config) {
         historiesLoaded: new Set(),
         intentRuntimes: persistedIntentRuntimes,
         intentRuntimesFile,
+        buildPickPending: new Map(),
         ws: null,
         seq: null,
         sessionId: null,
@@ -173,11 +175,12 @@ export function parseSnowflakeList(raw) {
 export const parseAllowedUserIds = parseSnowflakeList;
 export function classifyMessage(message, botUserId, allowedUserIds, listenChannelIds = new Set(), botThreadIds = new Set()) {
     const isDirect = !message.guild_id;
-    const isMentioned = botUserId
+    const isListenChannel = listenChannelIds.has(message.channel_id);
+    const hasBotUserMention = botUserId
         ? Array.isArray(message.mentions) && message.mentions.some((user) => user.id === botUserId)
         : false;
+    const isMentioned = hasBotUserMention || (isListenChannel && hasLeadingRoleMention(message));
     const isAllowed = allowedUserIds.has(message.author.id);
-    const isListenChannel = listenChannelIds.has(message.channel_id);
     const isBotThread = botThreadIds.has(message.channel_id);
     return { isDirect, isMentioned, isAllowed, isListenChannel, isBotThread };
 }
@@ -186,7 +189,13 @@ export function stripBotMention(content, botUserId) {
         return content.trim();
     }
     const pattern = new RegExp(`<@!?${botUserId}>`, "g");
-    return content.replace(pattern, "").trim();
+    return stripLeadingRoleMentions(content.replace(pattern, "")).trim();
+}
+function hasLeadingRoleMention(message) {
+    return /^\s*(?:<@&\d+>\s*)+/u.test(message.content || "");
+}
+function stripLeadingRoleMentions(content) {
+    return content.replace(/^\s*(?:<@&\d+>\s*)+/u, "");
 }
 const BADGE_PREFIX_PATTERN = /^(💬|🔧|✏️|✏)/u;
 const BUILD_FOOTER_FIRST_LINE = /^(?:(?:✏️|✏|🔧)\s*現在ビルドモードです|（(?:現在：「[^」]*」の)?ビルドモード(?:です。抜けるには|を抜けるには).+?と返事してください）)\s*$/u;
@@ -453,7 +462,7 @@ async function persistDiscordAttachmentBuffer(state, attachment, buffer, mimeTyp
         const HH = String(now.getHours()).padStart(2, "0");
         const mm = String(now.getMinutes()).padStart(2, "0");
         const ss = String(now.getSeconds()).padStart(2, "0");
-        const dir = path.join(state.config.notes_dir, "attachments", yyyy, MM);
+        const dir = path.join(state.config.memory_dir, "attachments", yyyy, MM);
         await mkdir(dir, { recursive: true });
         const ext = pickAttachmentExtension(attachment.filename || attachment.title, mimeType);
         const random = Math.random().toString(36).slice(2, 8);
@@ -726,9 +735,11 @@ async function handleMessage(state, message) {
                     is_listen_channel: ctx.isListenChannel,
                     is_bot_thread: ctx.isBotThread,
                     mention_count: Array.isArray(message.mentions) ? message.mentions.length : 0,
+                    role_mention_count: Array.isArray(message.mention_roles) ? message.mention_roles.length : 0,
                     mention_user_ids: Array.isArray(message.mentions)
                         ? message.mentions.map((user) => user.id).slice(0, 5)
                         : [],
+                    mention_role_ids: Array.isArray(message.mention_roles) ? message.mention_roles.slice(0, 5) : [],
                     bot_user_id: state.botUserId,
                 },
             });
@@ -745,6 +756,7 @@ async function handleMessage(state, message) {
     if (cleanText === "!reset") {
         state.histories.delete(message.channel_id);
         state.historiesLoaded.delete(message.channel_id);
+        state.buildPickPending.delete(message.channel_id);
         await sendChannelMessage(state, message.channel_id, l("Chat history reset.", "会話履歴をリセットしました。"));
         return;
     }
@@ -753,6 +765,25 @@ async function handleMessage(state, message) {
         await sendChannelMessage(state, message.channel_id, lines.join("\n"));
         return;
     }
+    if (cleanText === "/build") {
+        const lines = await startBuildPickerForChannel(state, message.channel_id);
+        await sendChannelMessage(state, message.channel_id, lines.join("\n"));
+        return;
+    }
+    const buildSlashSkillId = parseSlashBuildDirect(cleanText);
+    if (buildSlashSkillId) {
+        const lines = await enterBuildModeFromSlashForChannel(state, message.channel_id, buildSlashSkillId);
+        if (lines) {
+            await sendChannelMessage(state, message.channel_id, lines.join("\n"));
+            return;
+        }
+    }
+    const pendingPick = state.buildPickPending.get(message.channel_id);
+    if (pendingPick && /^\d+$/.test(cleanText.trim())) {
+        const lines = await resolveBuildPickSelection(state, message.channel_id, pendingPick, cleanText.trim());
+        await sendChannelMessage(state, message.channel_id, lines.join("\n"));
+        return;
+    }
     if (cleanText === "/models") {
         const lines = await modelsLines(state.config);
         await sendChannelMessage(state, message.channel_id, lines.join("\n"));
@@ -761,6 +792,9 @@ async function handleMessage(state, message) {
     if (await tryRunTodoSlashCommand(state, message, cleanText)) {
         return;
     }
+    if (await tryRunMemoSlashCommand(state, message, cleanText)) {
+        return;
+    }
     if (await tryRunModelSlashCommand(state, message, cleanText)) {
         return;
     }
@@ -835,20 +869,20 @@ async function handleMessage(state, message) {
         const typing = startTypingKeepalive(state, replyChannelId);
         const prevMode = intentRuntime.mode;
         try {
-            const lines = await routeDiscordMessage(state, userText, history, intentRuntime, status, replyChannelId, userMessage.images);
+            const routed = await routeDiscordMessage(state, userText, history, intentRuntime, status, replyChannelId, userMessage.images);
             typing.stop();
             void saveIntentRuntimes(state);
             const isBuildEntry = prevMode !== "build" && intentRuntime.mode === "build";
-            const decorated = withModeBadge(intentRuntime, lines, { userText, isBuildEntry });
+            const decorated = withModeBadge(intentRuntime, routed.lines, { userText, isBuildEntry });
             scheduleUpdateCheck(state.config.workspace);
             const banner = await consumeUpdateBanner(state.config.workspace);
             const finalLines = banner ? [banner, "", ...decorated] : decorated;
             const reply = finalLines.filter((line) => line !== undefined && line !== null).join("\n").trim();
             if (reply) {
-                await sendChannelMessage(state, replyChannelId, reply);
+                await sendChannelMessageWithLocalAttachments(state, replyChannelId, reply, routed.localAttachmentPaths);
             }
             else {
-                await sendChannelMessage(state, replyChannelId, l("(no response)", "（応答なし）"));
+                await sendChannelMessageWithLocalAttachments(state, replyChannelId, l("(no response)", "（応答なし）"), routed.localAttachmentPaths);
             }
         }
         catch (error) {
@@ -897,6 +931,7 @@ async function refreshDiscordHistoryBeforeCurrentMessage(state, channelId, befor
 }
 async function routeDiscordMessage(state, text, history, intentRuntime, status, replyChannelId, images = []) {
     let modelFailed = false;
+    const localAttachmentPaths = [];
     const lines = await routeConversationMessage({
         config: state.config,
         text,
@@ -913,9 +948,12 @@ async function routeDiscordMessage(state, text, history, intentRuntime, status,
                 modelFailed = true;
             }
         },
+        onLocalAttachments: (paths) => {
+            localAttachmentPaths.push(...paths);
+        },
     });
     await status.set(modelFailed ? "error" : "done");
-    return lines;
+    return { lines, localAttachmentPaths };
 }
 async function onChatProgressForReactions(event, status) {
     switch (event.kind) {
@@ -1224,6 +1262,179 @@ async function tryRunTodoSlashCommand(state, message, cleanText) {
     });
     return true;
 }
+export function parseMemoSlashCommand(text) {
+    const trimmed = (text || "").trim();
+    if (trimmed !== "/memo" && !/^\/memo\s/.test(trimmed)) {
+        return null;
+    }
+    const rest = trimmed === "/memo" ? "" : trimmed.replace(/^\/memo\s+/, "").trim();
+    if (!rest || rest === "help" || rest === "--help" || rest === "-h") {
+        return { kind: "help", lines: memoSlashHelpLines() };
+    }
+    const firstSpace = rest.search(/\s/);
+    const sub = (firstSpace >= 0 ? rest.slice(0, firstSpace) : rest).toLowerCase();
+    const remainder = firstSpace >= 0 ? rest.slice(firstSpace + 1).trim() : "";
+    if (sub === "add" || sub === "save") {
+        if (!remainder) {
+            return { kind: "error", lines: [l("Usage: /memo add <text>", "使い方: /memo add <本文>")] };
+        }
+        return { kind: "run", skillId: "memo-save", args: { text: remainder } };
+    }
+    if (sub === "list" || sub === "ls") {
+        const parsed = parseMemoListArgs(remainder);
+        if (parsed.kind === "error")
+            return parsed;
+        return { kind: "run", skillId: "memo-list", args: parsed.args };
+    }
+    if (sub === "delete" || sub === "remove" || sub === "del") {
+        const parsed = parseMemoDeleteArgs(remainder);
+        if (parsed.kind === "error")
+            return parsed;
+        return { kind: "run", skillId: "memo-delete", args: parsed.args };
+    }
+    return {
+        kind: "error",
+        lines: [
+            l(`Unknown subcommand: ${sub}.`, `未対応のサブコマンドです: ${sub}。`),
+            ...memoSlashHelpLines(),
+        ],
+    };
+}
+function parseMemoListArgs(rest) {
+    let body = rest.trim();
+    const dateFlag = extractValueFlag(body, "date");
+    body = dateFlag.text;
+    const limitFlag = extractValueFlag(body, "limit");
+    body = limitFlag.text;
+    const args = {};
+    const bodyParts = body.split(/\s+/).filter(Boolean);
+    if (dateFlag.value) {
+        args.date = dateFlag.value;
+    }
+    else if (bodyParts.length > 0) {
+        args.date = bodyParts[0];
+        bodyParts.shift();
+    }
+    if (bodyParts.length > 0) {
+        return { kind: "error", lines: [l("Usage: /memo list [YYYY-MM-DD] [--limit 20]", "使い方: /memo list [YYYY-MM-DD] [--limit 20]")] };
+    }
+    if (limitFlag.value) {
+        const limit = parseIntegerOption(limitFlag.value);
+        if (!limit || limit < 1 || limit > 50) {
+            return { kind: "error", lines: [l("limit must be an integer from 1 to 50.", "limit は 1〜50 の整数で指定してください。")] };
+        }
+        args.limit = limit;
+    }
+    return { kind: "ok", args };
+}
+function parseMemoDeleteArgs(rest) {
+    let target = rest.trim();
+    const dateFlag = extractValueFlag(target, "date");
+    target = dateFlag.text.trim();
+    const args = {};
+    if (dateFlag.value)
+        args.date = dateFlag.value;
+    if (!target) {
+        return { kind: "error", lines: [l("Usage: /memo delete <index|text> [--date YYYY-MM-DD]", "使い方: /memo delete <番号|本文> [--date YYYY-MM-DD]")] };
+    }
+    const numeric = parseIntegerOption(target);
+    if (numeric && String(numeric) === target) {
+        args.index = numeric;
+    }
+    else {
+        args.match = target;
+    }
+    return { kind: "ok", args };
+}
+function extractValueFlag(rest, name) {
+    const pattern = new RegExp(`(^|\\s)--${escapeRegExp(name)}\\s+(\\S+)(?=\\s|$)`);
+    const match = rest.match(pattern);
+    if (!match)
+        return { text: rest.trim() };
+    const start = match.index ?? 0;
+    const before = rest.slice(0, start);
+    const after = rest.slice(start + match[0].length);
+    const text = [before, after].map((segment) => segment.trim()).filter(Boolean).join(" ").trim();
+    return { text, value: match[2] };
+}
+function parseIntegerOption(value) {
+    if (!/^\d+$/.test(value.trim()))
+        return null;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isSafeInteger(parsed) ? parsed : null;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function memoSlashHelpLines() {
+    return lLines([
+        "Memo commands:",
+        "/memo add <text> - save a memo",
+        "/memo list [YYYY-MM-DD] [--limit 20] - list memos",
+        "/memo delete <index|text> [--date YYYY-MM-DD] - delete a memo",
+    ], [
+        "メモのショートカット:",
+        "/memo add <本文> - メモを追加",
+        "/memo list [YYYY-MM-DD] [--limit 20] - メモを一覧表示",
+        "/memo delete <番号|本文> [--date YYYY-MM-DD] - メモを削除",
+    ]);
+}
+async function tryRunMemoSlashCommand(state, message, cleanText) {
+    const parsed = await withLocale(inferLocaleFromText(cleanText), () => Promise.resolve(parseMemoSlashCommand(cleanText)));
+    if (!parsed)
+        return false;
+    await withLocale(inferLocaleFromText(cleanText), async () => {
+        const status = createStatusReactor(state, message.channel_id, message.id);
+        await status.set("received");
+        if (parsed.kind === "help") {
+            await status.set("done");
+            await sendChannelMessage(state, message.channel_id, parsed.lines.join("\n"));
+            return;
+        }
+        if (parsed.kind === "error") {
+            await status.set("error");
+            await sendChannelMessage(state, message.channel_id, parsed.lines.join("\n"));
+            return;
+        }
+        await status.set("tool");
+        try {
+            const response = await runSkill(state.config, parsed.skillId, parsed.args);
+            const display = response.result.summary ||
+                response.result.title ||
+                l("(no response)", "（応答なし）");
+            await status.set(response.result.status === "ok" ? "done" : "error");
+            await sendChannelMessage(state, message.channel_id, display);
+            await appendEventLog(state.config, {
+                level: "info",
+                source: "discord",
+                event: "memo_slash_ran",
+                message: response.result.title || undefined,
+                details: {
+                    skill_id: parsed.skillId,
+                    status: response.result.status,
+                    channel_id: message.channel_id,
+                },
+            });
+        }
+        catch (error) {
+            await status.set("error");
+            const detail = error instanceof SkillRunError
+                ? error.originalMessage
+                : error instanceof Error
+                    ? error.message
+                    : String(error);
+            await sendChannelMessage(state, message.channel_id, l(`Error: ${detail}`, `エラー: ${detail}`));
+            await appendEventLog(state.config, {
+                level: "error",
+                source: "discord",
+                event: "memo_slash_failed",
+                message: detail.slice(0, 200),
+                details: { skill_id: parsed.skillId, channel_id: message.channel_id },
+            });
+        }
+    });
+    return true;
+}
 export function parseModelSlashCommand(text) {
     const trimmed = (text || "").trim();
     if (trimmed !== "/model" && !/^\/model\s/.test(trimmed)) {
@@ -1428,6 +1639,84 @@ const TODO_SLASH_COMMAND_DEFINITION = {
         },
     ],
 };
+const MEMO_SLASH_COMMAND_DEFINITION = {
+    name: "memo",
+    description: "Memo shortcut commands",
+    description_localizations: { ja: "メモのショートカット" },
+    type: 1,
+    dm_permission: true,
+    options: [
+        {
+            type: 1,
+            name: "add",
+            description: "Save a memo",
+            description_localizations: { ja: "メモを追加" },
+            options: [
+                {
+                    type: 3,
+                    name: "text",
+                    description: "Memo text",
+                    description_localizations: { ja: "メモ本文" },
+                    required: true,
+                },
+            ],
+        },
+        {
+            type: 1,
+            name: "list",
+            description: "List memos",
+            description_localizations: { ja: "メモを一覧表示" },
+            options: [
+                {
+                    type: 3,
+                    name: "date",
+                    description: "Target date (YYYY-MM-DD, default today)",
+                    description_localizations: { ja: "対象日（YYYY-MM-DD、省略時は今日）" },
+                    required: false,
+                },
+                {
+                    type: 4,
+                    name: "limit",
+                    description: "Maximum number of memos",
+                    description_localizations: { ja: "表示する最大件数" },
+                    required: false,
+                    min_value: 1,
+                    max_value: 50,
+                },
+            ],
+        },
+        {
+            type: 1,
+            name: "delete",
+            description: "Delete a memo",
+            description_localizations: { ja: "メモを削除" },
+            options: [
+                {
+                    type: 4,
+                    name: "index",
+                    description: "Memo number from /memo list",
+                    description_localizations: { ja: "/memo list の番号" },
+                    required: false,
+                    min_value: 1,
+                },
+                {
+                    type: 3,
+                    name: "match",
+                    description: "Text contained in the memo",
+                    description_localizations: { ja: "メモに含まれる文字" },
+                    required: false,
+                },
+                {
+                    type: 3,
+                    name: "date",
+                    description: "Target date (YYYY-MM-DD, default today)",
+                    description_localizations: { ja: "対象日（YYYY-MM-DD、省略時は今日）" },
+                    required: false,
+                },
+            ],
+        },
+    ],
+};
 const MODEL_SLASH_COMMAND_DEFINITION = {
     name: "model",
     description: "Show or switch the chat model",
@@ -1447,6 +1736,7 @@ const MODEL_SLASH_COMMAND_DEFINITION = {
 };
 const BUILTIN_SLASH_COMMAND_DEFINITIONS = [
     TODO_SLASH_COMMAND_DEFINITION,
+    MEMO_SLASH_COMMAND_DEFINITION,
     MODEL_SLASH_COMMAND_DEFINITION,
 ];
 const DISCORD_SLASH_OPTION_TYPE_CODE = {
@@ -1590,6 +1880,12 @@ async function handleInteraction(state, interaction) {
         }
         return;
     }
+    if (name === "memo") {
+        if (interaction.type === 2) {
+            await handleMemoInteraction(state, interaction);
+        }
+        return;
+    }
     if (name === "model") {
         if (interaction.type === 4) {
             await handleModelAutocomplete(state, interaction);
@@ -1774,6 +2070,106 @@ async function handleTodoInteraction(state, interaction) {
         }
     });
 }
+async function handleMemoInteraction(state, interaction) {
+    const userId = await ensureInteractionUserAllowed(state, interaction, "memo");
+    if (!userId)
+        return;
+    const sub = interaction.data?.options?.[0];
+    const subName = sub?.name || "";
+    const optMap = new Map();
+    for (const opt of sub?.options || []) {
+        optMap.set(opt.name, opt.value);
+    }
+    await withLocale(inferLocaleFromText(extractInteractionLocaleHint(sub)), async () => {
+        let skillId;
+        let args;
+        if (subName === "add") {
+            const text = String(optMap.get("text") || "").trim();
+            if (!text) {
+                await respondInteraction(state, interaction, {
+                    content: l("Memo text is required.", "メモ本文を指定してください。"),
+                    ephemeral: true,
+                });
+                return;
+            }
+            skillId = "memo-save";
+            args = { text };
+        }
+        else if (subName === "list") {
+            skillId = "memo-list";
+            args = {};
+            const date = String(optMap.get("date") || "").trim();
+            if (date)
+                args.date = date;
+            const limit = optMap.get("limit");
+            if (typeof limit === "number")
+                args.limit = limit;
+        }
+        else if (subName === "delete") {
+            skillId = "memo-delete";
+            args = {};
+            const date = String(optMap.get("date") || "").trim();
+            const match = String(optMap.get("match") || "").trim();
+            const index = optMap.get("index");
+            if (date)
+                args.date = date;
+            if (typeof index === "number")
+                args.index = index;
+            if (match)
+                args.match = match;
+            if (args.index === undefined && !args.match) {
+                await respondInteraction(state, interaction, {
+                    content: l("Specify a memo number or matching text.", "番号か一致する本文を指定してください。"),
+                    ephemeral: true,
+                });
+                return;
+            }
+        }
+        else {
+            await respondInteraction(state, interaction, {
+                content: l(`Unknown subcommand: ${subName || "(none)"}.`, `未対応のサブコマンドです: ${subName || "(なし)"}。`),
+                ephemeral: true,
+            });
+            return;
+        }
+        const ack = await deferInteraction(state, interaction);
+        if (!ack)
+            return;
+        try {
+            const response = await runSkill(state.config, skillId, args);
+            const display = response.result.summary ||
+                response.result.title ||
+                l("(no response)", "（応答なし）");
+            await editInteractionOriginal(state, interaction, display);
+            await appendEventLog(state.config, {
+                level: "info",
+                source: "discord",
+                event: "memo_slash_ran",
+                message: response.result.title || undefined,
+                details: {
+                    skill_id: skillId,
+                    status: response.result.status,
+                    kind: "interaction",
+                },
+            });
+        }
+        catch (error) {
+            const detail = error instanceof SkillRunError
+                ? error.originalMessage
+                : error instanceof Error
+                    ? error.message
+                    : String(error);
+            await editInteractionOriginal(state, interaction, l(`Error: ${detail}`, `エラー: ${detail}`));
+            await appendEventLog(state.config, {
+                level: "error",
+                source: "discord",
+                event: "memo_slash_failed",
+                message: detail.slice(0, 200),
+                details: { skill_id: skillId, kind: "interaction" },
+            });
+        }
+    });
+}
 async function handleModelInteraction(state, interaction) {
     const userId = await ensureInteractionUserAllowed(state, interaction, "model");
     if (!userId)
@@ -2070,6 +2466,72 @@ async function editInteractionOriginal(state, interaction, content) {
         }
     }
 }
+async function enterBuildModeFromSlashForChannel(state, channelId, skillId) {
+    if (!skillId)
+        return null;
+    const skills = await listSkillManifests(state.config.skills_dir);
+    const userSkills = skills.filter((skill) => skill.source !== "builtin");
+    const exists = userSkills.some((skill) => skill.id === skillId);
+    if (!exists) {
+        const head = l(`"${skillId}" is not a registered user skill. Pick one below:`, `「${skillId}」は登録済みのユーザースキルではありません。下から番号で選んでください:`);
+        const picker = await startBuildPickerForChannel(state, channelId);
+        return [head, ...picker];
+    }
+    state.buildPickPending.delete(channelId);
+    let intentRuntime = state.intentRuntimes.get(channelId);
+    if (!intentRuntime) {
+        intentRuntime = createIntentRuntime(true);
+        state.intentRuntimes.set(channelId, intentRuntime);
+    }
+    const lines = await enterEditModeForSkill(state.config, skillId, intentRuntime, "discord");
+    if (isEmptyIntentRuntime(intentRuntime)) {
+        state.intentRuntimes.delete(channelId);
+    }
+    else {
+        state.intentRuntimes.set(channelId, intentRuntime);
+    }
+    void saveIntentRuntimes(state);
+    return lines;
+}
+async function startBuildPickerForChannel(state, channelId) {
+    const skills = await listSkillManifests(state.config.skills_dir);
+    const userSkills = skills.filter((skill) => skill.source !== "builtin");
+    if (userSkills.length === 0) {
+        state.buildPickPending.delete(channelId);
+        return [
+            l("No user-created skills yet. Ask in chat to create one.", "編集できるスキルはまだありません。チャットで新しく作成を依頼してください。"),
+        ];
+    }
+    state.buildPickPending.set(channelId, { skillIds: userSkills.map((skill) => skill.id) });
+    const header = l("Pick a skill to edit. Reply with a number:", "編集するスキルを番号で返信してください:");
+    const rows = userSkills.map((skill, index) => {
+        const enabled = skill.enabled === false ? l("disabled", "無効") : l("enabled", "有効");
+        return `  ${String(index + 1).padStart(2)}) ${skill.id} — ${skill.name} (${enabled})`;
+    });
+    return [header, ...rows];
+}
+async function resolveBuildPickSelection(state, channelId, pending, pickText) {
+    const num = Number.parseInt(pickText, 10);
+    if (!Number.isInteger(num) || num < 1 || num > pending.skillIds.length) {
+        return [l("Invalid selection. Send `/build` again to redisplay the list.", "無効な選択です。もう一度 `/build` を送ってください。")];
+    }
+    state.buildPickPending.delete(channelId);
+    const skillId = pending.skillIds[num - 1];
+    let intentRuntime = state.intentRuntimes.get(channelId);
+    if (!intentRuntime) {
+        intentRuntime = createIntentRuntime(true);
+        state.intentRuntimes.set(channelId, intentRuntime);
+    }
+    const lines = await enterEditModeForSkill(state.config, skillId, intentRuntime, "discord");
+    if (isEmptyIntentRuntime(intentRuntime)) {
+        state.intentRuntimes.delete(channelId);
+    }
+    else {
+        state.intentRuntimes.set(channelId, intentRuntime);
+    }
+    void saveIntentRuntimes(state);
+    return lines;
+}
 function handleProgressCommand(state, channelId, text) {
     if (text !== "!progress" && !text.startsWith("!progress ")) {
         return null;
@@ -2174,6 +2636,76 @@ async function sendChannelMessage(state, channelId, content) {
         }
     }
 }
+async function sendChannelMessageWithLocalAttachments(state, channelId, content, localAttachmentPaths = []) {
+    const explicitAttachments = await collectLocalFileAttachments({
+        paths: localAttachmentPaths,
+        cwd: state.config.workspace,
+        allowedRoots: [state.config.workspace, state.config.notes_dir],
+    });
+    const inlineImages = await collectLocalImageAttachments({
+        text: content,
+        cwd: state.config.workspace,
+        allowedRoots: [state.config.workspace, state.config.notes_dir],
+    });
+    const attachments = dedupeLocalAttachments([...explicitAttachments, ...inlineImages]);
+    if (content.trim()) {
+        await sendChannelMessage(state, channelId, content);
+    }
+    for (const attachment of attachments) {
+        await sendDiscordFileAttachment(state, channelId, attachment);
+    }
+}
+async function sendDiscordFileAttachment(state, channelId, attachment) {
+    try {
+        const buffer = await readFile(attachment.path);
+        const form = new FormData();
+        form.append("payload_json", JSON.stringify({ content: "" }));
+        form.append("files[0]", blobFromBuffer(buffer, attachment.mimeType), attachment.filename);
+        const response = await fetch(`${REST_BASE}/channels/${channelId}/messages`, {
+            method: "POST",
+            headers: { authorization: `Bot ${state.token}` },
+            body: form,
+        });
+        if (!response.ok) {
+            const detail = await response.text().catch(() => "");
+            console.error(`agent-sin discord: file send failed: HTTP ${response.status}: ${detail.slice(0, 200)}`);
+            await appendEventLog(state.config, {
+                level: "error",
+                source: "discord",
+                event: "file_send_failed",
+                message: `HTTP ${response.status}`,
+                details: { channel_id: channelId, path: attachment.path },
+            });
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`agent-sin discord: file send error: ${message}`);
+        await appendEventLog(state.config, {
+            level: "error",
+            source: "discord",
+            event: "file_send_error",
+            message,
+            details: { channel_id: channelId, path: attachment.path },
+        });
+    }
+}
+function dedupeLocalAttachments(attachments) {
+    const seen = new Set();
+    const out = [];
+    for (const attachment of attachments) {
+        if (seen.has(attachment.path))
+            continue;
+        seen.add(attachment.path);
+        out.push(attachment);
+    }
+    return out;
+}
+function blobFromBuffer(buffer, type) {
+    const bytes = new Uint8Array(buffer.length);
+    bytes.set(buffer);
+    return new Blob([bytes.buffer], { type });
+}
 async function sendTypingIndicator(state, channelId) {
     try {
         await fetch(`${REST_BASE}/channels/${channelId}/typing`, {