agent-sin 0.1.10 → 0.1.12

package/CHANGELOG.md

@@ -15,6 +15,27 @@ See the [compatibility policy](https://agent.shingoirie.com/versioning) for deta
 
 ---
 
+## [0.1.12] — 2026-05-15
+
+### Added
+
+- `/memo` slash command on Discord (`add` / `list` / `delete`), plus a new built-in `memo-list` skill that backs it.
+
+### Fixed
+
+- Telegram replies no longer leak internal `skill-call` / `agent-sin-build-suggestion` fence blocks. Both the live draft preview and the final sent message now strip these control blocks, including malformed variants where the language tag ends up on its own line.
+- Chat skill invocation is more tolerant of malformed `skill-call` blocks, and exact read-only triggers such as `todolist` run without waiting for the model to format a call.
+
+---
+
+## [0.1.11] — 2026-05-14
+
+### Fixed
+
+- The interactive startup banner now uses a plain `AGENT-SIN` wordmark on Windows. The previous half-block terminal logo could render slightly misaligned in Windows Terminal depending on font and line-height settings.
+
+---
+
 ## [0.1.10] — 2026-05-14
 
 ### Fixed

package/builtin-skills/memo-list/main.py

@@ -0,0 +1,125 @@
+"""Builtin: memo-list
+
+memo-save が書き込むデイリーノートからメモ行を読み、削除時に使える
+1始まり番号つきで表示する。
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+from datetime import datetime
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "_shared"))
+from i18n import localizer  # noqa: E402
+
+
+_DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
+_MEMO_LINE_RE = re.compile(r"^-\s+")
+_CONTINUATION_RE = re.compile(r"^  \S")
+_MEMO_HEAD_RE = re.compile(r"^-\s+(?:\d{4}-\d{2}-\d{2}T\S+\s+)?")
+
+
+async def run(ctx, input):
+    loc = localizer(input)
+    args = input.get("args", {}) or {}
+    notes_dir = input.get("sources", {}).get("notes_dir", "")
+    if not notes_dir:
+        return _err(loc.t("Notes unavailable", "ノート不明"), loc.t("notes_dir is unavailable.", "notes_dir が取得できません"))
+
+    date_str = str(args.get("date", "")).strip()
+    if not date_str:
+        date_str = datetime.now().strftime("%Y-%m-%d")
+    if not _DATE_RE.match(date_str):
+        return _err(loc.t("Invalid date", "日付不正"), loc.t("Use YYYY-MM-DD for date.", "date は YYYY-MM-DD 形式で指定してください"))
+
+    limit = int(args.get("limit", 20))
+    year, month, _ = date_str.split("-")
+    path = os.path.join(notes_dir, year, month, f"{date_str}.md")
+    if not os.path.exists(path):
+        return _ok(loc.t("No memos", "メモなし"), loc.t(f"No memos for {date_str}.", f"{date_str} のメモはありません"), [], date_str, path)
+
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            raw = f.read()
+    except OSError as e:
+        return _err(loc.t("Cannot read", "読み取り失敗"), loc.t(f"Failed to read {path}: {e}", f"{path} を読み取れませんでした: {e}"))
+
+    memos = _collect_memos(raw.splitlines(keepends=False))
+    shown = memos[:limit]
+    if not shown:
+        return _ok(loc.t("No memos", "メモなし"), loc.t(f"No memo lines for {date_str}.", f"{date_str} にメモ行はありません"), [], date_str, path)
+
+    lines = [loc.t(f"Memos for {date_str}:", f"{date_str} のメモ:")]
+    for item in shown:
+        lines.append(f"{item['index']}. {item['text']}")
+    if len(memos) > len(shown):
+        lines.append(loc.t(f"...and {len(memos) - len(shown)} more", f"...他 {len(memos) - len(shown)} 件"))
+
+    title = loc.t(f"{len(memos)} memos", f"メモ {len(memos)}件")
+    return _ok(title, "\n".join(lines), shown, date_str, path, total=len(memos))
+
+
+def _collect_memos(lines):
+    items = []
+    i = 0
+    while i < len(lines):
+        if _MEMO_LINE_RE.match(lines[i]):
+            start = i
+            body = [_clean_head(lines[i])]
+            j = i + 1
+            while j < len(lines) and _CONTINUATION_RE.match(lines[j]):
+                body.append(lines[j].strip())
+                j += 1
+            text = " / ".join(part for part in body if part)
+            items.append(
+                {
+                    "index": len(items) + 1,
+                    "line": start + 1,
+                    "text": _snippet(text),
+                }
+            )
+            i = j
+        else:
+            i += 1
+    return items
+
+
+def _clean_head(line):
+    return _MEMO_HEAD_RE.sub("", line, count=1).strip()
+
+
+def _snippet(text):
+    compact = " ".join(str(text).split())
+    if len(compact) <= 160:
+        return compact
+    return compact[:157] + "..."
+
+
+def _ok(title, summary, memos, date_str, path, total=None):
+    return {
+        "status": "ok",
+        "title": title,
+        "summary": summary,
+        "outputs": {},
+        "data": {
+            "date": date_str,
+            "memos": memos,
+            "count": len(memos),
+            "total": len(memos) if total is None else total,
+            "path": path,
+        },
+        "suggestions": [],
+    }
+
+
+def _err(title, summary):
+    return {
+        "status": "error",
+        "title": title,
+        "summary": summary,
+        "outputs": {},
+        "data": {},
+        "suggestions": [],
+    }

package/builtin-skills/memo-list/skill.yaml

@@ -0,0 +1,57 @@
+# Builtin: memo-list
+# memo-save が書き込むデイリーノートのメモ行を一覧表示する。
+
+id: memo-list
+name: Memo List
+name_i18n:
+  en: Memo List
+  ja: メモ一覧
+description: 指定日のMarkdownメモを一覧表示する
+description_i18n:
+  en: List Markdown memos for a date
+  ja: 指定日のMarkdownメモを一覧表示する
+runtime: python
+output_mode: raw
+
+invocation:
+  command: memo.list
+  phrases:
+    - メモ一覧
+    - メモを見せて
+    - 今日のメモ
+  phrases_i18n:
+    en:
+      - list memos
+      - show memos
+      - today's memos
+    ja:
+      - メモ一覧
+      - メモを見せて
+      - 今日のメモ
+
+input:
+  schema:
+    type: object
+    additionalProperties: false
+    properties:
+      date:
+        type: string
+        description: "対象日 (YYYY-MM-DD)。省略時は今日"
+        description_i18n:
+          en: "Target date (YYYY-MM-DD). Defaults to today"
+          ja: "対象日 (YYYY-MM-DD)。省略時は今日"
+      limit:
+        type: integer
+        minimum: 1
+        maximum: 50
+        default: 20
+        description: 表示する最大件数
+        description_i18n:
+          en: Maximum number of memos to show
+          ja: 表示する最大件数
+    required: []
+
+memory:
+  namespace: memo
+  read: true
+  write: false

package/dist/cli/index.js

@@ -1347,9 +1347,10 @@ function renderStartupBanner(state) {
     const accent = (text) => paintCode(BRAND_GREEN_ANSI, text, ctx);
     const dot = dim(glyph("dot", ctx));
     const modelDisplay = resolveDisplayModel(state);
-    if (ctx.ascii) {
+    if (ctx.ascii || process.platform === "win32") {
         return [
             "",
+            `  ${accent("AGENT-SIN")}`,
             `  ${bold("agent-sin")}  ${dim("v" + AGENT_SIN_VERSION)}  ${dot}  ${dim("model:")} ${modelDisplay}`,
             `  ${dim("/help · /reset · /exit")}`,
             "",

package/dist/core/chat-engine.d.ts

@@ -62,6 +62,7 @@ export declare function stripSkillCalls(text: string): string;
 export declare function extractSkillCallBlocks(text: string): string;
 export declare function parseBuildSuggestion(text: string): ChatBuildSuggestion | null;
 export declare function stripBuildSuggestions(text: string): string;
+export declare function stripInternalControlBlocks(text: string): string;
 export declare function toolResultJson(id: string, status: string, summary: string, saved?: string[], data?: unknown): string;
 export declare function toAiMessages(history: ChatTurn[], multimodalTurn?: {
     index: number;

package/dist/core/chat-engine.js

@@ -9,8 +9,9 @@ import { maybePromoteDailyMemory } from "./daily-memory-promotion.js";
 import { l, t } from "./i18n.js";
 export const HISTORY_LIMIT = 20;
 export const TOOL_CALL_MAX_ITERATIONS = 3;
-const SKILL_CALL_PATTERN = /```skill-call\s*\n([\s\S]*?)\n```/g;
-const BUILD_SUGGESTION_PATTERN = /```agent-sin-build-suggestion\s*\n([\s\S]*?)\n```/g;
+const SKILL_CALL_BLOCK = "skill-call";
+const BUILD_SUGGESTION_BLOCK = "agent-sin-build-suggestion";
+const INTERNAL_BLOCK_NAMES = [SKILL_CALL_BLOCK, BUILD_SUGGESTION_BLOCK];
 const REPAIR_FAILURE_PATTERN = /(traceback|exception|runtimeerror|syntaxerror|typeerror|nameerror|valueerror|importerror|module not found|exited with code|did not return valid json|handler not found|entry file not found|実行時|例外|エラー|失敗|読み取れません|できませんでした)/i;
 const USER_FIXABLE_FAILURE_PATTERN = /(missing required env vars|invalid input for|is disabled|skill not found|not allowed|設定してください|必要な設定|未入力|アプリパスワード|api[_ -]?key|token|credentials?)/i;
 export async function chatRespond(config, userText, history, options = {}) {
@@ -33,6 +34,8 @@ export async function chatRespond(config, userText, history, options = {}) {
     const profileMemory = await readProfileMemoryForPrompt(config);
     const systemPrompt = buildSystemPrompt(tools, options.preferredSkillId, profileMemory);
     const modelDisplay = await resolveDisplayModelName(config);
+    const directSkillCall = resolveDirectSkillCall(tools, userText, options.preferredSkillId);
+    let queuedAssistantText = directSkillCall ? formatSkillCallBlock(directSkillCall) : null;
     appendHistory(history, { role: "user", content: userText });
     const userTurnIndex = history.length - 1;
     const userImages = options.userImages || [];
@@ -63,91 +66,97 @@ export async function chatRespond(config, userText, history, options = {}) {
     for (let iteration = 0; iteration < TOOL_CALL_MAX_ITERATIONS; iteration += 1) {
         let assistantText;
         let buildSuggestion = null;
-        const baseLabel = `${modelDisplay}: ${t("spinner.thinking")}`;
-        if (spinner)
-            spinner.start(baseLabel);
-        emitProgress({ kind: "thinking", iteration });
-        const spinnerProgress = spinner ? makeSpinnerProgress(spinner, baseLabel) : null;
-        const providerProgress = spinnerProgress || options.onAiProgress
-            ? (event) => {
-                if (spinnerProgress) {
-                    spinnerProgress(event);
-                }
-                if (options.onAiProgress) {
-                    options.onAiProgress(event);
+        if (queuedAssistantText) {
+            assistantText = queuedAssistantText;
+            queuedAssistantText = null;
+        }
+        else {
+            const baseLabel = `${modelDisplay}: ${t("spinner.thinking")}`;
+            if (spinner)
+                spinner.start(baseLabel);
+            emitProgress({ kind: "thinking", iteration });
+            const spinnerProgress = spinner ? makeSpinnerProgress(spinner, baseLabel) : null;
+            const providerProgress = spinnerProgress || options.onAiProgress
+                ? (event) => {
+                    if (spinnerProgress) {
+                        spinnerProgress(event);
+                    }
+                    if (options.onAiProgress) {
+                        options.onAiProgress(event);
+                    }
                 }
-            }
-            : undefined;
-        try {
-            const messages = [
-                { role: "system", content: systemPrompt },
-                ...toAiMessages(history, userImages.length > 0 ? { index: userTurnIndex, images: userImages } : undefined),
-            ];
-            const provider = getAiProvider();
-            const response = await provider(config, {
-                model_id: config.chat_model_id,
-                messages,
-                onProgress: providerProgress,
-            });
-            buildSuggestion = parseBuildSuggestion(response.text);
-            assistantText = stripBuildSuggestions(response.text);
-            if (shouldRetryEmptyAssistantReply(assistantText, buildSuggestion)) {
-                await appendEventLog(config, {
-                    level: "warn",
-                    source: eventSource,
-                    event: "empty_model_reply_retry",
-                    message: "model returned an empty chat reply; retrying once",
-                    details: { model_id: config.chat_model_id, iteration },
+                : undefined;
+            try {
+                const messages = [
+                    { role: "system", content: systemPrompt },
+                    ...toAiMessages(history, userImages.length > 0 ? { index: userTurnIndex, images: userImages } : undefined),
+                ];
+                const provider = getAiProvider();
+                const response = await provider(config, {
+                    model_id: config.chat_model_id,
+                    messages,
+                    onProgress: providerProgress,
                 });
-                try {
-                    const retryResponse = await provider(config, {
-                        model_id: config.chat_model_id,
-                        messages: [
-                            ...messages,
-                            { role: "system", content: emptyReplyRetryPrompt() },
-                        ],
-                        onProgress: providerProgress,
-                    });
-                    buildSuggestion = parseBuildSuggestion(retryResponse.text);
-                    assistantText = stripBuildSuggestions(retryResponse.text);
-                }
-                catch (retryError) {
-                    const retryMessage = retryError instanceof Error ? retryError.message : String(retryError);
+                buildSuggestion = parseBuildSuggestion(response.text);
+                assistantText = stripBuildSuggestions(response.text);
+                if (shouldRetryEmptyAssistantReply(assistantText, buildSuggestion)) {
                     await appendEventLog(config, {
                         level: "warn",
                         source: eventSource,
-                        event: "empty_model_reply_retry_failed",
-                        message: retryMessage,
+                        event: "empty_model_reply_retry",
+                        message: "model returned an empty chat reply; retrying once",
                         details: { model_id: config.chat_model_id, iteration },
                     });
+                    try {
+                        const retryResponse = await provider(config, {
+                            model_id: config.chat_model_id,
+                            messages: [
+                                ...messages,
+                                { role: "system", content: emptyReplyRetryPrompt() },
+                            ],
+                            onProgress: providerProgress,
+                        });
+                        buildSuggestion = parseBuildSuggestion(retryResponse.text);
+                        assistantText = stripBuildSuggestions(retryResponse.text);
+                    }
+                    catch (retryError) {
+                        const retryMessage = retryError instanceof Error ? retryError.message : String(retryError);
+                        await appendEventLog(config, {
+                            level: "warn",
+                            source: eventSource,
+                            event: "empty_model_reply_retry_failed",
+                            message: retryMessage,
+                            details: { model_id: config.chat_model_id, iteration },
+                        });
+                    }
                 }
-            }
-            if (buildSuggestion && options.onBuildSuggestion) {
-                try {
-                    options.onBuildSuggestion(buildSuggestion);
-                }
-                catch {
-                    // Build suggestions are optional metadata; never break chat.
+                if (buildSuggestion && options.onBuildSuggestion) {
+                    try {
+                        options.onBuildSuggestion(buildSuggestion);
+                    }
+                    catch {
+                        // Build suggestions are optional metadata; never break chat.
+                    }
                 }
             }
-        }
-        catch (error) {
+            catch (error) {
+                if (spinner)
+                    spinner.stop();
+                const message = error instanceof Error ? error.message : String(error);
+                history.pop();
+                await appendEventLog(config, {
+                    level: "error",
+                    source: eventSource,
+                    event: "model_failed",
+                    message,
+                    details: { model_id: config.chat_model_id },
+                });
+                emitProgress({ kind: "model_failed", message });
+                return [t("chat.model_unreachable", { model: config.chat_model_id, message })];
+            }
             if (spinner)
                 spinner.stop();
-            const message = error instanceof Error ? error.message : String(error);
-            history.pop();
-            await appendEventLog(config, {
-                level: "error",
-                source: eventSource,
-                event: "model_failed",
-                message,
-                details: { model_id: config.chat_model_id },
-            });
-            emitProgress({ kind: "model_failed", message });
-            return [t("chat.model_unreachable", { model: config.chat_model_id, message })];
         }
-        if (spinner)
-            spinner.stop();
         const calls = parseSkillCalls(assistantText);
         const narrative = stripSkillCalls(assistantText).trim();
         // When the response invokes a side-effect skill (add/delete/send/save),
@@ -720,18 +729,18 @@ function stableStringify(value) {
 }
 export function parseSkillCalls(text) {
     const calls = [];
-    SKILL_CALL_PATTERN.lastIndex = 0;
-    let match;
-    while ((match = SKILL_CALL_PATTERN.exec(text)) !== null) {
+    for (const block of findInternalControlBlocks(text, [SKILL_CALL_BLOCK])) {
         try {
-            const parsed = JSON.parse(match[1]);
-            if (typeof parsed.id !== "string") {
+            const parsed = JSON.parse(block.payload);
+            const id = parsed.id ?? parsed.skill_id ?? parsed.skillId;
+            if (typeof id !== "string") {
                 continue;
             }
-            const args = parsed.args && typeof parsed.args === "object" && !Array.isArray(parsed.args)
-                ? parsed.args
+            const rawArgs = parsed.args ?? parsed.arguments ?? parsed.input;
+            const args = rawArgs && typeof rawArgs === "object" && !Array.isArray(rawArgs)
+                ? rawArgs
                 : {};
-            calls.push({ id: parsed.id, args });
+            calls.push({ id, args });
         }
         catch {
             continue;
@@ -740,35 +749,275 @@ export function parseSkillCalls(text) {
     return calls;
 }
 export function stripSkillCalls(text) {
-    return text.replace(SKILL_CALL_PATTERN, "").trim();
+    return removeInternalControlBlocks(text, [SKILL_CALL_BLOCK]).trim();
 }
 export function extractSkillCallBlocks(text) {
-    const matches = text.match(SKILL_CALL_PATTERN);
-    return matches ? matches.join("\n") : "";
+    const blocks = findInternalControlBlocks(text, [SKILL_CALL_BLOCK]);
+    return blocks.map((block) => text.slice(block.start, block.end).trim()).join("\n");
 }
 export function parseBuildSuggestion(text) {
-    BUILD_SUGGESTION_PATTERN.lastIndex = 0;
-    const match = BUILD_SUGGESTION_PATTERN.exec(text);
-    if (!match)
+    for (const block of findInternalControlBlocks(text, [BUILD_SUGGESTION_BLOCK])) {
+        try {
+            const parsed = JSON.parse(block.payload);
+            const type = parsed.type === "edit" ? "edit" : "create";
+            const skillId = sanitizeSuggestedSkillId(String(parsed.skill_id || ""));
+            if (!skillId)
+                continue;
+            return {
+                type,
+                skill_id: skillId,
+                reason: typeof parsed.reason === "string" ? parsed.reason.slice(0, 240) : undefined,
+            };
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+export function stripBuildSuggestions(text) {
+    return removeInternalControlBlocks(text, [BUILD_SUGGESTION_BLOCK]).trim();
+}
+export function stripInternalControlBlocks(text) {
+    return removeInternalControlBlocks(text, INTERNAL_BLOCK_NAMES)
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+function findInternalControlBlocks(text, names) {
+    const wanted = new Set(names.map(normalizeInternalBlockName));
+    const lines = splitLinesWithOffsets(text);
+    const blocks = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const fence = line.text.match(/^\s*(`{3,}|~{3,})\s*([A-Za-z][A-Za-z0-9_-]*)?\s*$/);
+        if (fence) {
+            let name = normalizeInternalBlockName(fence[2] || "");
+            let payloadStartLine = index + 1;
+            if (!name && payloadStartLine < lines.length) {
+                const splitName = normalizeInternalBlockName(lines[payloadStartLine].text.trim());
+                if (wanted.has(splitName)) {
+                    name = splitName;
+                    payloadStartLine += 1;
+                }
+            }
+            if (wanted.has(name)) {
+                const closeLine = findClosingFenceLine(lines, payloadStartLine, fence[1]);
+                const payloadStart = payloadStartLine < lines.length ? lines[payloadStartLine].start : line.end;
+                const payloadEnd = closeLine >= 0 ? lines[closeLine].start : text.length;
+                const end = closeLine >= 0 ? lines[closeLine].end : text.length;
+                blocks.push({
+                    name,
+                    payload: text.slice(payloadStart, payloadEnd).trim(),
+                    start: line.start,
+                    end,
+                });
+                index = closeLine >= 0 ? closeLine : lines.length;
+                continue;
+            }
+        }
+        const bareName = normalizeInternalBlockName(line.text.trim());
+        if (!wanted.has(bareName)) {
+            continue;
+        }
+        const payloadLine = nextNonEmptyLine(lines, index + 1);
+        if (payloadLine < 0) {
+            continue;
+        }
+        const jsonStart = firstNonWhitespaceIndex(text, lines[payloadLine].start);
+        if (jsonStart < 0 || text[jsonStart] !== "{") {
+            continue;
+        }
+        const jsonEnd = findJsonObjectEnd(text, jsonStart);
+        if (!jsonEnd) {
+            continue;
+        }
+        blocks.push({
+            name: bareName,
+            payload: text.slice(jsonStart, jsonEnd).trim(),
+            start: line.start,
+            end: consumeTrailingLineWhitespace(text, jsonEnd),
+        });
+        index = lineIndexForOffset(lines, jsonEnd);
+    }
+    return mergeInternalBlocks(blocks);
+}
+function removeInternalControlBlocks(text, names) {
+    const blocks = findInternalControlBlocks(text, names);
+    if (blocks.length === 0) {
+        return text;
+    }
+    let out = "";
+    let cursor = 0;
+    for (const block of blocks) {
+        if (block.start < cursor) {
+            continue;
+        }
+        out += text.slice(cursor, block.start);
+        cursor = block.end;
+    }
+    out += text.slice(cursor);
+    return out;
+}
+function splitLinesWithOffsets(text) {
+    const lines = [];
+    let start = 0;
+    while (start < text.length) {
+        const newline = text.indexOf("\n", start);
+        const end = newline >= 0 ? newline + 1 : text.length;
+        const contentEnd = newline >= 0 ? newline : end;
+        const raw = text.slice(start, contentEnd).replace(/\r$/, "");
+        lines.push({ text: raw, start, end });
+        start = end;
+    }
+    if (text.length === 0) {
+        lines.push({ text: "", start: 0, end: 0 });
+    }
+    return lines;
+}
+function findClosingFenceLine(lines, startLine, openingFence) {
+    const char = openingFence[0];
+    const minLength = openingFence.length;
+    for (let index = startLine; index < lines.length; index += 1) {
+        const trimmed = lines[index].text.trim();
+        if (trimmed.length < minLength) {
+            continue;
+        }
+        if ([...trimmed].every((item) => item === char)) {
+            return index;
+        }
+    }
+    return -1;
+}
+function nextNonEmptyLine(lines, startLine) {
+    for (let index = startLine; index < lines.length; index += 1) {
+        if (lines[index].text.trim()) {
+            return index;
+        }
+    }
+    return -1;
+}
+function firstNonWhitespaceIndex(text, start) {
+    for (let index = start; index < text.length; index += 1) {
+        if (!/\s/.test(text[index])) {
+            return index;
+        }
+    }
+    return -1;
+}
+function findJsonObjectEnd(text, start) {
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = start; index < text.length; index += 1) {
+        const char = text[index];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === "\\") {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            continue;
+        }
+        if (char === "{") {
+            depth += 1;
+            continue;
+        }
+        if (char === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                return index + 1;
+            }
+        }
+    }
+    return null;
+}
+function consumeTrailingLineWhitespace(text, start) {
+    let index = start;
+    while (index < text.length && (text[index] === " " || text[index] === "\t" || text[index] === "\r")) {
+        index += 1;
+    }
+    if (text[index] === "\n") {
+        index += 1;
+    }
+    return index;
+}
+function lineIndexForOffset(lines, offset) {
+    for (let index = 0; index < lines.length; index += 1) {
+        if (offset <= lines[index].end) {
+            return index;
+        }
+    }
+    return lines.length - 1;
+}
+function mergeInternalBlocks(blocks) {
+    const sorted = blocks.sort((a, b) => a.start - b.start || b.end - a.end);
+    const merged = [];
+    for (const block of sorted) {
+        const previous = merged[merged.length - 1];
+        if (previous && block.start < previous.end) {
+            continue;
+        }
+        merged.push(block);
+    }
+    return merged;
+}
+function normalizeInternalBlockName(value) {
+    return value.trim().toLowerCase().replaceAll("_", "-");
+}
+function formatSkillCallBlock(call) {
+    return ["```skill-call", safeJson({ id: call.id, args: call.args }), "```"].join("\n");
+}
+function resolveDirectSkillCall(skills, userText, preferredSkillId) {
+    const normalizedText = normalizeSkillTrigger(userText);
+    if (!normalizedText) {
         return null;
-    try {
-        const parsed = JSON.parse(match[1]);
-        const type = parsed.type === "edit" ? "edit" : "create";
-        const skillId = sanitizeSuggestedSkillId(String(parsed.skill_id || ""));
-        if (!skillId)
-            return null;
-        return {
-            type,
-            skill_id: skillId,
-            reason: typeof parsed.reason === "string" ? parsed.reason.slice(0, 240) : undefined,
-        };
     }
-    catch {
+    const candidates = skills
+        .filter((skill) => skill.output_mode === "raw" && !skill.side_effect && hasNoRequiredArgs(skill))
+        .map((skill) => ({
+        skill,
+        phrases: directSkillPhrases(skill),
+    }))
+        .filter((entry) => entry.phrases.some((phrase) => normalizeSkillTrigger(phrase) === normalizedText));
+    if (preferredSkillId) {
+        const preferred = candidates.find((entry) => entry.skill.id === preferredSkillId);
+        if (preferred) {
+            return { id: preferred.skill.id, args: {} };
+        }
+    }
+    if (candidates.length !== 1) {
         return null;
     }
+    return { id: candidates[0].skill.id, args: {} };
 }
-export function stripBuildSuggestions(text) {
-    return text.replace(BUILD_SUGGESTION_PATTERN, "").trim();
+function directSkillPhrases(skill) {
+    return [
+        skill.id,
+        skill.name,
+        skill.invocation?.command || "",
+        ...(skill.invocation?.phrases || []),
+    ].filter((phrase) => phrase.trim().length > 0);
+}
+function hasNoRequiredArgs(skill) {
+    const required = skill.input?.schema?.required;
+    return !Array.isArray(required) || required.length === 0;
+}
+function normalizeSkillTrigger(value) {
+    return value
+        .normalize("NFKC")
+        .toLowerCase()
+        .replace(/^\/+/, "")
+        .replace(/(?:を|の)?(?:一覧|リスト)?(?:出して|表示して|見せて|教えて|ください|お願い|して)$/u, "")
+        .replace(/[\s_\-./:：・、。!！?？"'`]+/g, "")
+        .trim();
 }
 function sanitizeSuggestedSkillId(raw) {
     return raw

package/dist/discord/bot.d.ts

@@ -75,6 +75,18 @@ export type TodoSlashParse = {
     args: Record<string, unknown>;
 };
 export declare function parseTodoSlashCommand(text: string): TodoSlashParse | null;
+export type MemoSlashParse = {
+    kind: "help";
+    lines: string[];
+} | {
+    kind: "error";
+    lines: string[];
+} | {
+    kind: "run";
+    skillId: "memo-save" | "memo-list" | "memo-delete";
+    args: Record<string, unknown>;
+};
+export declare function parseMemoSlashCommand(text: string): MemoSlashParse | null;
 export type ModelSlashParse = {
     kind: "help";
     lines: string[];

package/dist/discord/bot.js

@@ -761,6 +761,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;
     }
@@ -1224,6 +1227,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 +1604,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 +1701,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 +1845,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 +2035,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)

package/dist/telegram/bot.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { loadConfig } from "../core/config.js";
 import { appendEventLog } from "../core/logger.js";
+import { stripInternalControlBlocks, } from "../core/chat-engine.js";
 import { createIntentRuntime, renderBuildFooter, shouldShowBuildFooter, } from "../builder/build-flow.js";
 import { routeConversationMessage, } from "../builder/conversation-router.js";
 import { cleanProgressText, formatBuildProgress, progressIntervalMs } from "../builder/progress-format.js";
@@ -527,31 +528,9 @@ function helpText() {
     return lLines([
         "Welcome to the Agent-Sin Telegram bot.",
         "It responds in DMs, mentions, and replies to the bot. Registered skills are called automatically when useful.",
-        "",
-        "Commands:",
-        "  /help                         Show this help",
-        "  /reset                        Reset this chat history",
-        "  /progress quiet|detail         Toggle progress messages",
-        "  /back                         Return from build/edit mode to chat mode",
-        "  /build [skill-id] [request]    Create a new skill",
-        '  /build chat <id> "message"    Revise through conversation',
-        "  /build list                   List drafts",
-        "  /build test <id>              Test a draft",
-        "  /build status <id>            Show status",
     ], [
         "Agent-Sin Telegram bot へようこそ。",
         "DM、メンション、bot への返信に反応します。登録済みスキルも自動で呼び出されます。",
-        "",
-        "コマンド:",
-        "  /help                         この使い方を表示",
-        "  /reset                        このチャットの会話履歴をリセット",
-        "  /progress quiet|detail         進捗通知の量を切り替え",
-        "  /back                         build / edit モードから chat モードに戻る",
-        "  /build [skill-id] [要望]      新規スキルを作成",
-        '  /build chat <id> "メッセージ" 会話しながら修正',
-        "  /build list                   作成中の一覧",
-        "  /build test <id>              動作確認",
-        "  /build status <id>            状態を見る",
     ]).join("\n");
 }
 async function formatTelegramUserMessageForChat(state, message) {
@@ -1024,7 +1003,7 @@ function telegramDraftIntervalMs() {
     return 1500;
 }
 function cleanDraftText(text) {
-    const cleaned = text
+    const cleaned = stripInternalControlBlocks(text)
         .replace(/```/g, "")
         .replace(/\r\n/g, "\n")
         .replace(/\r/g, "\n")
@@ -1058,7 +1037,11 @@ function startTypingKeepalive(state, chatId, threadId) {
     };
 }
 async function sendTelegramMessage(state, chatId, content, options = {}) {
-    const chunks = chunkTelegramMessage(content);
+    const sanitized = stripInternalControlBlocks(content);
+    if (!sanitized.trim()) {
+        return;
+    }
+    const chunks = chunkTelegramMessage(sanitized);
     for (let index = 0; index < chunks.length; index += 1) {
         const chunk = chunks[index];
         const payload = telegramSendPayload(chatId, chunk, index === 0 ? options : { threadId: options.threadId });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sin",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Program Skill-first personal AI agent OS CLI.",
   "type": "module",
   "license": "MIT",