agent-sin 0.1.11 → 0.1.15

package/dist/core/chat-engine.js

@@ -1,18 +1,34 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 import { loadModels } from "./config.js";
-import { appendConversationLog, appendEventLog, readRunLog } from "./logger.js";
+import { appendConversationLog, appendEventLog, dailyConversationMemoryFile, readRunLog, } from "./logger.js";
 import { getAiProvider, } from "./ai-provider.js";
 import { listSkillManifests } from "./skill-registry.js";
 import { runSkill, SkillRunError } from "./runtime.js";
 import { buildDraftWithAgent, prepareRepairDraft, } from "../builder/builder-session.js";
-import { formatProfileMemoryPromptSection, readProfileMemoryForPrompt, } from "./profile-memory.js";
+import { formatProfileMemoryPromptSection, profileMemoryPath, readProfileMemoryForPrompt, } from "./profile-memory.js";
 import { maybePromoteDailyMemory } from "./daily-memory-promotion.js";
 import { l, t } from "./i18n.js";
+import { agentSinOperatingModelLines } from "./operating-model.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;
+export const TOOL_CALL_MAX_ITERATIONS = 8;
+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;
+const PATH_CANDIDATE_PATTERN = /(?:~\/|\/[A-Za-z0-9._-]+\/|Users\/)[^\s"'<>`]+/g;
+const MAX_FILE_CONTEXT_CHARS = 16000;
+const MAX_SINGLE_FILE_CHARS = 9000;
+const MAX_FILE_CONTEXT_ITEMS = 5;
+const MAX_DIRECTORY_ENTRIES = 40;
+const MAX_TOOL_RESULT_DATA_CHARS = 8000;
+const MAX_CONVERSATION_SEARCH_CONTEXT_CHARS = 12000;
+const MAX_CONVERSATION_SEARCH_FILES = 30;
+const MAX_CONVERSATION_SEARCH_RESULTS = 6;
+const MAX_CONVERSATION_SEARCH_TURN_CHARS = 700;
+const SERVICE_RESTART_SKILL_ID = "service-restart";
 export async function chatRespond(config, userText, history, options = {}) {
     const formatNarrative = options.formatNarrative ?? ((text) => text);
     const spinner = options.spinner;
@@ -31,8 +47,14 @@ export async function chatRespond(config, userText, history, options = {}) {
     const tools = skills.filter(isToolEligible);
     await maybePromoteDailyMemory(config, { eventSource });
     const profileMemory = await readProfileMemoryForPrompt(config);
-    const systemPrompt = buildSystemPrompt(tools, options.preferredSkillId, profileMemory);
+    const systemPrompt = buildSystemPrompt(tools, options.preferredSkillId, profileMemory, config);
+    const readOnlyFileContext = await buildReadOnlyFileContext(config, userText);
+    const conversationSearchContext = await buildConversationSearchContext(config, userText);
+    const topicKnowledgeIndex = await buildTopicKnowledgeIndexContext(config);
     const modelDisplay = await resolveDisplayModelName(config);
+    const directSkillCall = resolveDirectSkillCall(tools, userText, options.preferredSkillId);
+    let queuedAssistantText = directSkillCall ? formatAssistantEnvelope({ reply: "", skill_calls: [directSkillCall] }) : null;
+    const startedFromDirectTrigger = queuedAssistantText !== null;
     appendHistory(history, { role: "user", content: userText });
     const userTurnIndex = history.length - 1;
     const userImages = options.userImages || [];
@@ -58,98 +80,132 @@ export async function chatRespond(config, userText, history, options = {}) {
         return lines;
     };
     const completedCallKeys = new Set();
+    const localAttachmentPathSet = new Set();
+    const emitLocalAttachments = (paths) => {
+        handleLocalAttachments(paths, lines, options.onLocalAttachments || options.onGeneratedImages, localAttachmentPathSet);
+    };
     let lastCompletedSummary = "";
-    let pendingRawRangeStart = null;
+    // Buffer of skill-result display lines from the most recent iteration that
+    // ran skills. Intermediate iterations replace this buffer entirely — only
+    // the last batch survives. At terminal we show either the LLM's reply
+    // (reframe) OR this buffer (passthrough), never both, to avoid the
+    // duplication where the skill prints its own summary AND the LLM repeats it.
+    let lastSkillBuffer = [];
     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);
+        let assistantOutput = null;
+        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 },
+                    ...(topicKnowledgeIndex ? [{ role: "system", content: topicKnowledgeIndex }] : []),
+                    ...(readOnlyFileContext ? [{ role: "system", content: readOnlyFileContext }] : []),
+                    ...(conversationSearchContext ? [{ role: "system", content: conversationSearchContext }] : []),
+                    ...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,
+                    role: "chat",
+                    cwd: config.workspace,
+                    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);
+                emitLocalAttachments(response.generated_images);
+                assistantText = response.text;
+                assistantOutput = parseAssistantOutput(assistantText);
+                if (shouldRetryEmptyAssistantReply(assistantOutput, lastSkillBuffer.length > 0)) {
                     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() },
+                            ],
+                            role: "chat",
+                            cwd: config.workspace,
+                            onProgress: providerProgress,
+                        });
+                        emitLocalAttachments(retryResponse.generated_images);
+                        assistantText = retryResponse.text;
+                        assistantOutput = parseAssistantOutput(assistantText);
+                    }
+                    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 (assistantOutput.buildSuggestion && options.onBuildSuggestion) {
+                    try {
+                        options.onBuildSuggestion(assistantOutput.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();
+        assistantOutput = assistantOutput || parseAssistantOutput(assistantText);
+        const normalizedCalls = normalizeSkillCallsForExecution(assistantOutput.skillCalls);
+        const calls = normalizedCalls.calls;
+        const narrative = assistantOutput.reply.trim();
+        const buildSuggestion = assistantOutput.buildSuggestion;
+        const assistantTextForHistory = normalizedCalls.changed
+            ? formatAssistantEnvelope({
+                reply: assistantOutput.reply,
+                skill_calls: calls,
+                build_suggestion: buildSuggestion,
+            })
+            : assistantText;
         // When the response invokes a side-effect skill (add/delete/send/save),
         // drop the LLM's narrative entirely. The deterministic skill result is
         // the only record — both for the user and for future-turn history reads.
@@ -160,35 +216,9 @@ export async function chatRespond(config, userText, history, options = {}) {
             return tool?.side_effect === true;
         });
         const recordedAssistantText = hasSideEffectCall && narrative
-            ? extractSkillCallBlocks(assistantText)
-            : assistantText;
+            ? formatAssistantEnvelope({ reply: "", skill_calls: calls, build_suggestion: buildSuggestion })
+            : assistantTextForHistory;
         appendHistory(history, { role: "assistant", content: recordedAssistantText });
-        if (pendingRawRangeStart !== null) {
-            if (calls.length > 0) {
-                // Previous turn ran an output_mode: raw skill, but the model wants to
-                // call another tool (e.g. todo-list -> todo-done). The intermediate
-                // result is plumbing the user does not need to see — drop it.
-                lines.length = pendingRawRangeStart;
-                pendingRawRangeStart = null;
-            }
-            else {
-                // Previous raw skill result is the final answer; skip the LLM's
-                // narrative-only follow-up so the raw output stands alone.
-                return ensureVisibleReply();
-            }
-        }
-        if (narrative && !hasSideEffectCall) {
-            lines.push(formatNarrative(narrative));
-        }
-        else if (!narrative && calls.length === 0 && buildSuggestion) {
-            const prompt = buildSuggestion.type === "edit"
-                ? l("I can fix that in build mode. Should I continue?", "ビルドモードで直せます。進めますか？")
-                : l("I can create that in build mode. Should I continue?", "ビルドモードで作れます。進めますか？");
-            lines.push(formatNarrative(prompt));
-        }
-        else if (!narrative && calls.length === 0) {
-            lines.push(formatNarrative(emptyChatFallback()));
-        }
         await appendEventLog(config, {
             level: "info",
             source: eventSource,
@@ -199,34 +229,69 @@ export async function chatRespond(config, userText, history, options = {}) {
         await appendConversationLog(config, {
             source: "chat",
             role: "assistant",
-            content: assistantText,
+            content: assistantTextForHistory,
             model_id: config.chat_model_id,
             details: { iteration, skill_calls: calls.map((call) => call.id) },
         });
-        if (calls.length === 0) {
-            return ensureVisibleReply();
-        }
         const callsToRun = calls.filter((call) => !completedCallKeys.has(skillCallKey(call)));
-        if (callsToRun.length === 0) {
-            if (!narrative && lastCompletedSummary) {
+        // Terminal iteration: either model emitted no skill calls, or it tried to
+        // re-run already-completed calls (model is looping). Resolve the final
+        // user-facing output here. The rule is: show EITHER the model's reply OR
+        // the buffered skill output — never both — so the user never sees the
+        // same content twice.
+        if (calls.length === 0 || callsToRun.length === 0) {
+            if (callsToRun.length === 0 && calls.length > 0) {
+                await appendEventLog(config, {
+                    level: "info",
+                    source: eventSource,
+                    event: "tool_repeat_skipped",
+                    message: `model repeated already-completed skill calls: ${calls.map((call) => call.id).join(", ")}`,
+                    details: { model_id: config.chat_model_id, iteration },
+                });
+            }
+            if (startedFromDirectTrigger && lastSkillBuffer.length > 0) {
+                // User typed the exact skill phrase — the skill output IS the answer.
+                // Any model commentary on top is noise.
+                lines.push(...lastSkillBuffer);
+            }
+            else if (narrative && !hasSideEffectCall) {
+                // Model wrote a reply — it's the user-facing answer. The buffered
+                // skill output has already been incorporated (or intentionally
+                // dropped by the model).
+                lines.push(formatNarrative(narrative));
+            }
+            else if (lastSkillBuffer.length > 0) {
+                // No model commentary — passthrough the skill output.
+                lines.push(...lastSkillBuffer);
+            }
+            else if (lastCompletedSummary) {
+                // Model looped on completed calls and wrote nothing new — fall back
+                // to the most recent successful skill summary so the turn is not
+                // silent.
                 lines.push(formatNarrative(lastCompletedSummary));
             }
-            await appendEventLog(config, {
-                level: "info",
-                source: eventSource,
-                event: "tool_repeat_skipped",
-                message: `model repeated already-completed skill calls: ${calls.map((call) => call.id).join(", ")}`,
-                details: { model_id: config.chat_model_id, iteration },
-            });
+            else if (!narrative && buildSuggestion) {
+                const prompt = buildSuggestion.type === "edit"
+                    ? l("I can fix that with this approach. Should I proceed?", "この内容で直しますか？")
+                    : l("I can create that with this approach. Should I proceed?", "この内容で作りますか？");
+                lines.push(formatNarrative(prompt));
+            }
+            else if (!narrative) {
+                lines.push(formatNarrative(emptyChatFallback()));
+            }
             return ensureVisibleReply();
         }
-        const rawRangeStart = lines.length;
-        let allRawOk = callsToRun.length > 0;
+        // Non-terminal: skill calls present. The model's reply on this turn is
+        // premature (e.g. "I'll do X now") and would duplicate either the skill
+        // output or its own follow-up reply — drop it from the user-facing
+        // output. History keeps it (or strips it for side-effect skills) via the
+        // existing recordedAssistantText logic above.
+        const currentBuffer = [];
         for (const call of callsToRun) {
             const tool = tools.find((skill) => skill.id === call.id);
             if (!tool) {
                 const message = `[skill not allowed: ${call.id}]`;
-                lines.push(message);
+                currentBuffer.push(message);
                 appendHistory(history, { role: "tool", content: toolResultJson(call.id, "error", message) });
                 await appendEventLog(config, {
                     level: "warn",
@@ -235,11 +300,12 @@ export async function chatRespond(config, userText, history, options = {}) {
                     message,
                     details: { skill_id: call.id },
                 });
-                allRawOk = false;
                 continue;
             }
             const isRawMode = tool.output_mode === "raw";
             if (!isRawMode) {
+                // Status hint stays in lines so the user sees progress; it is not
+                // part of the "answer" buffer.
                 lines.push(t("chat.tool_call_announce", { skill: call.id }));
             }
             const execution = await runSkillCallWithSelfRepair(config, tool, call, userText, history, {
@@ -252,12 +318,13 @@ export async function chatRespond(config, userText, history, options = {}) {
                 const result = execution.response;
                 const summary = [result.result.title, result.result.summary].filter(Boolean).join(" / ");
                 const display = result.result.summary || result.result.title;
+                emitLocalAttachments(extractLocalAttachmentPathsFromSkillResult(result.result.data));
                 const saved = result.saved_outputs.filter((item) => item.show_saved !== false).map((item) => item.path);
                 if (display) {
-                    lines.push(display);
+                    currentBuffer.push(display);
                 }
                 for (const savedPath of saved) {
-                    lines.push(`saved: ${savedPath}`);
+                    currentBuffer.push(`saved: ${savedPath}`);
                 }
                 if (result.result.status === "ok") {
                     completedCallKeys.add(skillCallKey(call));
@@ -265,11 +332,14 @@ export async function chatRespond(config, userText, history, options = {}) {
                         lastCompletedSummary = display;
                     }
                 }
-                if (!isRawMode || result.result.status !== "ok") {
-                    allRawOk = false;
+                const historyData = prepareToolResultDataForHistory(result.result.data);
+                const skillNotes = [];
+                for (const entry of result.ctx_logs || []) {
+                    if (entry.level === "warn" || entry.level === "error") {
+                        skillNotes.push({ level: entry.level, message: entry.message });
+                    }
                 }
-                const historyData = isRawMode ? result.result.data : undefined;
-                const historyContent = toolResultJson(call.id, result.result.status, summary, saved, historyData);
+                const historyContent = toolResultJson(call.id, result.result.status, summary, saved, historyData, skillNotes.length > 0 ? skillNotes : undefined);
                 appendHistory(history, {
                     role: "tool",
                     content: historyContent,
@@ -284,7 +354,7 @@ export async function chatRespond(config, userText, history, options = {}) {
             }
             else {
                 const message = execution.errorMessage;
-                lines.push(`[skill error: ${message}]`);
+                currentBuffer.push(`[skill error: ${message}]`);
                 appendHistory(history, { role: "tool", content: toolResultJson(call.id, "error", message) });
                 await appendEventLog(config, {
                     level: "error",
@@ -293,15 +363,22 @@ export async function chatRespond(config, userText, history, options = {}) {
                     message,
                     details: { skill_id: call.id, args: call.args },
                 });
-                allRawOk = false;
             }
         }
-        if (allRawOk) {
-            pendingRawRangeStart = rawRangeStart;
+        // Each new skill-running iteration replaces the buffer. Intermediate
+        // results (e.g. todo-list output when the model chains into todo-done)
+        // are discarded — only the most recent batch survives to the terminal
+        // iteration.
+        lastSkillBuffer = currentBuffer;
+        // service-restart is a one-shot: the runtime restarts after this call so
+        // there is no point asking the model for a follow-up reply.
+        if (callsToRun.some((call) => call.id === SERVICE_RESTART_SKILL_ID)) {
+            lines.push(...lastSkillBuffer);
+            return ensureVisibleReply();
         }
     }
-    if (pendingRawRangeStart !== null) {
-        return ensureVisibleReply();
+    if (lastSkillBuffer.length > 0) {
+        lines.push(...lastSkillBuffer);
     }
     lines.push("[tool call iterations exhausted]");
     await appendEventLog(config, {
@@ -312,6 +389,73 @@ export async function chatRespond(config, userText, history, options = {}) {
     });
     return lines;
 }
+function extractLocalAttachmentPathsFromSkillResult(data) {
+    if (!data)
+        return [];
+    const keys = [
+        "filePaths",
+        "file_paths",
+        "files",
+        "attachmentPaths",
+        "attachment_paths",
+        "attachments",
+        "generated_images",
+        "generated_image_paths",
+        "generated_files",
+        "generated_file_paths",
+        "imagePaths",
+        "image_paths",
+        "images",
+    ];
+    const paths = [];
+    for (const key of keys) {
+        const value = data[key];
+        if (Array.isArray(value)) {
+            paths.push(...value.filter((item) => typeof item === "string"));
+        }
+    }
+    for (const key of [
+        "filePath",
+        "file_path",
+        "file",
+        "attachmentPath",
+        "attachment_path",
+        "attachment",
+        "generated_image",
+        "generated_image_path",
+        "generated_file",
+        "generated_file_path",
+        "imagePath",
+        "image_path",
+        "image",
+    ]) {
+        const value = data[key];
+        if (typeof value === "string") {
+            paths.push(value);
+        }
+    }
+    return [...new Set(paths.filter((item) => item.trim().length > 0))];
+}
+function handleLocalAttachments(paths, lines, onLocalAttachments, seen) {
+    const unique = [...new Set((paths || []).filter((item) => typeof item === "string" && item.trim()))]
+        .filter((item) => {
+        if (!seen)
+            return true;
+        if (seen.has(item))
+            return false;
+        seen.add(item);
+        return true;
+    });
+    if (unique.length === 0)
+        return;
+    if (onLocalAttachments) {
+        onLocalAttachments(unique);
+        return;
+    }
+    for (const filePath of unique) {
+        lines.push(`attachment: ${filePath}`);
+    }
+}
 async function runSkillCallWithSelfRepair(config, tool, call, userText, history, options) {
     const firstAttempt = await attemptSkillRun(config, call, options);
     const firstFailure = failureFromAttempt(firstAttempt);
@@ -502,6 +646,20 @@ function redactSensitiveValues(value) {
     }
     return out;
 }
+function prepareToolResultDataForHistory(data) {
+    if (!data || Object.keys(data).length === 0) {
+        return undefined;
+    }
+    const redacted = redactSensitiveValues(data);
+    const json = safeJson(redacted);
+    if (json.length <= MAX_TOOL_RESULT_DATA_CHARS) {
+        return redacted;
+    }
+    return {
+        _truncated: true,
+        _json: truncateForPrompt(json, MAX_TOOL_RESULT_DATA_CHARS),
+    };
+}
 function shouldAttemptSelfRepair(failure) {
     if (!failure.trim())
         return false;
@@ -595,7 +753,7 @@ export function formatProgressLabel(baseLabel, event) {
         case "tool":
             return `${baseLabel} — tool: ${event.name || "?"}${event.text ? ` ${event.text}` : ""}`;
         case "message":
-            return event.text ? `${baseLabel} — ${l("response", "応答")}: ${event.text}` : null;
+            return `${baseLabel} — ${l("preparing response", "応答を整理中")}`;
         case "info":
             return `${baseLabel} — ${event.text}`;
         case "stderr":
@@ -607,25 +765,59 @@ export function formatProgressLabel(baseLabel, event) {
 export function isToolEligible(skill) {
     return skill.enabled !== false;
 }
-export function buildSystemPrompt(skills, preferredSkillId, profileMemory) {
+export function buildSystemPrompt(skills, preferredSkillId, profileMemory, config) {
+    const workspacePath = config?.workspace;
     const lines = [
         "You are Agent-Sin conversation mode. Talk naturally with the user and call the registered skills below when useful.",
-        "You cannot call unregistered skills or run arbitrary CLI commands directly.",
+        "You cannot call unregistered skills or perform arbitrary side-effect CLI operations directly.",
         "",
         "Output language: respond in the same language as the user's most recent message. If the user wrote in Japanese, respond in Japanese; otherwise respond in English. Match the user's level of formality.",
         "",
+        "Agent-Sin overview:",
+        "- Agent-Sin is a personal AI agent that uses conversation mode for discussion and routing, and registered Program Skills for repeatable actions.",
+        "- Conversation mode may answer from the current conversation, long-term profile, and readable local files. It may not write files directly.",
+        "- Build mode is for creating or editing skills when the user explicitly wants implementation work.",
+        "",
+        ...agentSinOperatingModelLines("chat"),
+        "",
+        ...agentSinStorageGuideLines(config),
+        "",
         "Important constraint: conversation mode cannot rewrite files.",
         "- Conversation mode runs in a read-only sandbox. Do not try to edit, create, or delete skill.yaml, main.py, or arbitrary files.",
-        "- If a skill needs to be fixed or a new skill should be created, do not edit it yourself. Hand it to build mode after briefly confirming the direction.",
+        "- Reading relevant local files is allowed in conversation mode. A dedicated skill is not required just to inspect a file that the user asked about.",
+        workspacePath
+            ? `- Your working folder for this turn is: ${workspacePath}. Start file exploration there by default, but treat every file as read-only.`
+            : "- Your working folder is the runtime-provided cwd. Start file exploration there by default, but treat every file as read-only.",
+        "- You may inspect other readable paths outside the working folder when they are relevant to the user's question. Prefer targeted reads; do not broadly scan the user's home directory or system folders without a clear reason.",
+        "- If a read-only filesystem context is attached as a system message, use it directly. Do not say you need a separate reader skill for those files.",
+        "- When you rely on filesystem context in the final reply, briefly tell the user your working folder and the relevant high-level structure or locations you inspected. Keep this note short and natural.",
+        "- Do not claim that conversation mode can only read the Agent-Sin workspace just because it cannot write. If the information is not in the current conversation, long-term profile, or readable files, say that specific limit.",
+        "- Readable signals inside the workspace include: `logs/runs/<run-id>.json` (one file per skill execution: input.args, result.summary, result.data, ctx_logs), `logs/conversations/<YYYY-MM-DD>.jsonl` (daily chat history), and `data/<skill-id>.db` (per-skill SQLite store accumulated by `ctx.history`). Open them with sqlite3 / cat / jq when they help close a gap.",
+        "- Before sending your final reply, do a brief self-check: does this actually answer what the user asked? If a skill returned only aggregates while the user wanted detail (or vice versa), if numbers look implausible, or if the user mentioned something the skill result does not cover, verify against the readable signals above. Either correct the reply with the missing information, or state clearly what is missing/why and propose the next step (different skill call, build-mode handoff, or one clarifying question). Don't ship a reply that you yourself wouldn't accept as an answer.",
+        "- Files such as .env may contain secrets. Do not quote, summarize, or reveal API keys, tokens, cookies, passwords, or credentials. At most, say whether a needed setting appears present or missing.",
+        "- When the user pastes credentials (API keys, OAuth client id/secret, refresh tokens, calendar ids, app passwords, webhook URLs, etc.) anywhere in a message in any format, the host extracts them and saves them to ~/.agent-sin/.env automatically — you do NOT need to call a skill for that, and you must NOT say that chat mode cannot write files or that .env cannot be updated. If the user has just supplied the missing values, treat them as saved and continue. If something is still missing, just ask for the remaining piece in one short sentence — do not refuse.",
+        "- If the user wants to keep configuring a particular skill (filling in env vars, tweaking behavior, fixing details), suggest they send `/build <skill-id>` to jump into that skill's build mode. Mention it as a one-line hint, not as the entire reply.",
+        "- If a skill needs to be fixed or a new skill should be created and implementation should start now, do not edit it yourself. Hand it to build mode after the direction is clear.",
+        "- If the request is still exploratory, vague, or missing material requirements, keep the conversation in chat mode. Offer a concrete proposal plus one or two short clarifying questions instead of proposing build mode.",
         "- Do not say that you identified edits but were blocked, or that you could update it if write access were available. Ask only for build-mode handoff when editing is needed.",
         "",
-        "Response style:",
-        "- Always respond to the user in plain text. Do not use Markdown styling, headings, bullet markers, numbered lists, inline code, fenced code blocks, links, or tables. If content is list-like, write it as plain sentences or simple line breaks. The only exception is the hidden internal fenced block described below.",
+        "Required response envelope:",
+        "- Return exactly one JSON object. Do not wrap it in Markdown fences. Do not write text before or after the JSON.",
+        "- The JSON object must have this shape: {\"reply\":\"visible user text\",\"skill_calls\":[],\"build_suggestion\":null}.",
+        "- reply is the only text shown to the user. Keep reply as plain text: no Markdown styling, headings, bullet markers, numbered lists, inline code, fenced code blocks, links, or tables. If content is list-like, write it as plain sentences or simple line breaks.",
+        "- skill_calls is an array of skill calls: {\"id\":\"<skill-id>\",\"args\":{...}}. Use an empty array when no skill should run.",
+        "- build_suggestion is null unless you are ready to create or edit a skill now. For a handoff, use {\"type\":\"create|edit\",\"skill_id\":\"<kebab-case-id>\",\"reason\":\"<short reason>\"}.",
         "- Do not volunteer command syntax or usage lists. For typo-like input, infer the intent and answer directly, or ask one short question if needed.",
-        "- If the user is naturally asking to create a new skill or edit an existing one, do not start implementing inside conversation mode. Briefly say what should be built or changed, then end with a one-line confirmation in the user's language (e.g. 'Should I switch to build mode to fix this?' / 'ビルドモードに入って直しますか？').",
-        "- On any turn that asks for that confirmation, or that says you are handing off to build mode, include one hidden agent-sin-build-suggestion block at the end. If you mention a handoff without the block, no handoff happens.",
-        "- If the user has already agreed with a short approval such as 'yes', 'go ahead', 'please do it', はい, お願い, 進めて, you may proceed with the handoff, but the same response must still include the block.",
-        "- For agent-sin-build-suggestion, use type=create for a new skill and type=edit for an existing skill. skill_id must be a short kebab-case id. For edits, use an id from the available skills list.",
+        "- Use build_suggestion only when the user explicitly asks to create/fix/build now (e.g. 作って, 直して, 実装して, build it, fix it), or after prior discussion has narrowed the desired behavior enough that you are asking for final confirmation.",
+        "- Do not use build_suggestion just because the user says they want a skill, wonders if a skill is possible, or describes an idea. Phrases like 欲しい, できる？, あるといい, would be useful, or I want should usually be treated as discussion unless they also clearly ask you to make it now.",
+        "- If information is insufficient, reply with a concise proposed default behavior and ask the smallest useful question. Keep build_suggestion null.",
+        "- For example, 'URLを読んで調べられるスキルが欲しい' is not enough for build_suggestion. Propose what the URL reader should return and ask what page types or output format matter.",
+        "- If the user is ready to create a new skill or edit an existing one, do not start implementing inside conversation mode. Briefly say what should be built or changed, then end with a one-line confirmation only when the user has not already given an explicit make/fix instruction.",
+        "- Do not tell the user only that you are switching, handing off, or passing the task to build mode. Either ask a clear confirmation such as 'この内容で直しますか？' or emit build_suggestion so the host can start implementation.",
+        "- When you emit build_suggestion, the reply field must still briefly summarize WHAT you will create or change (1-3 short sentences), then end with the confirmation question (e.g. 'この内容で直しますか？' / 'この内容で作りますか？'). Do not return an empty reply just because build_suggestion is set, and do not mention 'build mode', 'handoff', '渡します', or similar internal terminology in the reply.",
+        "- On any turn that asks for that confirmation, or that says implementation should start, put the handoff object in build_suggestion. If you mention a handoff while build_suggestion is null, no handoff happens.",
+        "- If the user has already agreed with a short approval such as 'yes', 'go ahead', 'please do it', はい, お願い, 進めて, or explicitly says 作って/直して, you may proceed with the handoff, but the same response must still include build_suggestion.",
+        "- For build_suggestion, use type=create for a new skill and type=edit for an existing skill. skill_id must be a short kebab-case id. For edits, use an id from the available skills list.",
         "- For edits, never invent umbrella ids such as 'todo'. If the request spans several available skills, explain the split briefly and ask which exact skill should be changed first.",
         "- Do not explain internal storage details such as builtin packaging, workspace copies, or override flags unless the user explicitly asks.",
         "- If the user explicitly asks for help (!help, /help, etc.), another route shows help text. You do not need to create a command list yourself.",
@@ -645,16 +837,29 @@ export function buildSystemPrompt(skills, preferredSkillId, profileMemory) {
         "- Call read/search skills only when needed to answer the user's question.",
         "",
         "Tool result handling:",
-        "- If the immediately previous turn has a tool result (skill-result block), do not emit the same skill-call again. Use the result and give only the short conclusion in the user's language.",
+        "- You may chain skills within one user request. After a skill-result, decide whether another different skill is needed, using summary/data; stop once the request is complete.",
+        "- If the immediately previous turn has a tool result (skill-result block), do not emit the same skill call again. Use the result and give only the short conclusion in the user's language.",
         "- Do not call the same skill with the same arguments more than once for one request. Once it succeeds, stop and tell the user it is done.",
-        "- skill-call blocks in history are past call records. Do not copy them. Emit a new call only when truly needed.",
+        "- skill_calls in assistant history are past call records. Do not copy them. Emit a new call only when truly needed.",
         "- skill-result JSON may include a data field in addition to summary. If a later skill call needs values such as ids, read them from data instead of asking the user.",
         "- If history already contains the same id and args with a status: ok skill-result, it has already run. Do not rerun it; just say it is already done or already registered.",
+        "- A skill-result may include a notes field with {level: warn|error, message} entries. Treat them as internal diagnostics from the skill run. If status is ok but notes contain error/warn entries, the skill likely degraded silently (e.g. fell back to cached data). Investigate the affected skill (open its source, fix the root cause) instead of presenting it to the user as a feature.",
+        "",
+        "Reply vs. skill output — pick exactly one, never both:",
+        "- After a skill returns, the user sees EITHER your reply OR the skill's output, never both. Choose deliberately so the user does not read the same content twice.",
+        "- If the skill's summary already directly answers the user's question (lists, schedules, reports, confirmations from save/delete/send), leave reply empty (\"\") so the skill output passes through as-is. This is the right choice for most skills marked (raw output) or (side effect).",
+        "- If you need to summarize, filter, pick out a value, or add interpretation, write your reply with the relevant content included. The skill's own summary will NOT be shown — incorporate the necessary details into reply yourself.",
+        "- Never write reply that just restates or paraphrases what the skill already said. That is the duplication we are avoiding.",
+        "- When chaining skills, only the final iteration's resolution matters: intermediate skill outputs are dropped automatically.",
         "",
         "How to call side-effect skills:",
-        "- For skills marked '(side effect)', do not write a preface or completion text in the response body. Output only the skill-call block.",
-        "- Do not write narration such as 'I will add it now', 'Added', or 'I will register it' together with a skill-call. The skill result provides the definitive completion text.",
-        "- If arguments need confirmation, do not emit a skill-call. Ask briefly in the body, wait for yes, then emit the call in the next response.",
+        "- For skills marked '(side effect)', set reply to an empty string and put only the call in skill_calls.",
+        "- Do not write narration such as 'I will add it now', 'Added', or 'I will register it' together with a side-effect skill call. The skill result provides the definitive completion text.",
+        "- If arguments need confirmation, do not emit a skill call. Ask briefly in reply, wait for yes, then emit the call in the next response.",
+        "- When calling memo-save, include args.tags with 1-3 short Obsidian tags based on the memo content. Use no leading #, avoid generic memo/note/date tags, and prefer stable project/topic tags.",
+        "- If Agent-Sin itself, the bot, gateway, service, .env, or settings need a restart to apply changes, do not just tell the user to restart manually. Ask for permission in one short sentence. If the user already clearly asked for the restart, or approves after you asked, call service-restart with empty args.",
+        "- Never call service-restart with any other skill in the same response, and do not pass delay_ms. If the user asks to restart and then test, call only service-restart; after reconnecting the user can send the test request again.",
+        "- If service-restart fails or is unavailable, then give the shortest terminal fallback: agent-sin service restart.",
         "",
         "ToDo handling:",
         "- When the user wants to complete/delete a specific ToDo, first call todo-list, identify the matching item id from data.items, then call todo-done or todo-delete with that id. Do not ask the user for the id.",
@@ -673,7 +878,11 @@ export function buildSystemPrompt(skills, preferredSkillId, profileMemory) {
     }
     else {
         for (const skill of skills) {
-            const tag = skill.side_effect ? " (side effect)" : "";
+            const tags = [
+                skill.side_effect ? "side effect" : "",
+                skill.output_mode === "raw" ? "raw output" : "",
+            ].filter(Boolean);
+            const tag = tags.length > 0 ? ` (${tags.join(", ")})` : "";
             lines.push(`- ${skill.id}${tag}: ${skill.description || skill.name}`);
             const phrases = skill.invocation?.phrases?.filter((p) => typeof p === "string" && p.trim().length > 0) || [];
             if (phrases.length > 0) {
@@ -683,30 +892,735 @@ export function buildSystemPrompt(skills, preferredSkillId, profileMemory) {
         }
     }
     lines.push("");
-    lines.push("When calling a skill, include a fenced block in this format:");
-    lines.push("```skill-call");
-    lines.push('{"id": "<skill-id>", "args": { ... }}');
-    lines.push("```");
-    lines.push("Multiple blocks are allowed. Run results are passed in the next turn with the `tool` role.");
-    lines.push("When asking to create or edit a skill, include exactly one internal block in this format. Without it, build-mode handoff will not happen:");
-    lines.push("```agent-sin-build-suggestion");
-    lines.push('{"type":"create|edit","skill_id":"<kebab-case-id>","reason":"<short reason>"}');
-    lines.push("```");
-    lines.push("Conversation mode cannot rewrite files directly. When a skill must be fixed or created, do not write it yourself; ask for confirmation with the block above and hand off to build mode after the user's approval.");
-    lines.push("If no skill call is needed, reply naturally in the user's language.");
+    lines.push("Examples:");
+    lines.push('{"reply":"わかりました。確認します。","skill_calls":[{"id":"memo-search","args":{"query":"King Coding Project","limit":10}}],"build_suggestion":null}');
+    lines.push('{"reply":"URLを読むスキルなら、本文要約、重要ポイント、気になる点、関連リンクまで返す形がよさそうです。対象は通常のWebページだけでよいですか？PDFやログインが必要なページも含めますか？","skill_calls":[],"build_suggestion":null}');
+    lines.push('{"reply":"その内容で通知分類を直せます。この内容で直しますか？","skill_calls":[],"build_suggestion":{"type":"edit","skill_id":"gmail-organizer-ai","reason":"notification classification needs improvement"}}');
+    lines.push('{"reply":"了解しました。","skill_calls":[],"build_suggestion":null}');
+    lines.push("Multiple skill calls are allowed in skill_calls. Skill results are fed back during the same request with the `tool` role, so dependent calls such as list -> done are allowed.");
+    lines.push("Conversation mode cannot rewrite files directly. When a skill must be fixed or created now, do not write it yourself; use build_suggestion only after the user's intent is explicit or the requirements are clear enough for final confirmation.");
+    lines.push("If no skill call is needed, put the natural reply in reply, use skill_calls: [], and build_suggestion: null.");
     return lines.join("\n");
 }
+function agentSinStorageGuideLines(config) {
+    const workspace = config?.workspace || "~/.agent-sin";
+    const memoryDir = config?.memory_dir || path.join(workspace, "memory");
+    const notesDir = config?.notes_dir || path.join(workspace, "notes");
+    const skillsDir = config?.skills_dir || path.join(workspace, "skills");
+    const logsDir = config?.logs_dir || path.join(workspace, "logs");
+    return [
+        "Agent-Sin storage map:",
+        `- Workspace root: ${workspace}`,
+        `- Configuration: ${path.join(workspace, "config.toml")}, ${path.join(workspace, "models.yaml")}, ${path.join(workspace, "schedules.yaml")}`,
+        `- Secrets: ${path.join(workspace, ".env")} (sensitive; never reveal values)`,
+        `- Long-term profile: ${path.join(memoryDir, "profile", "soul.md")}, ${path.join(memoryDir, "profile", "user.md")}, ${path.join(memoryDir, "profile", "memory.md")}`,
+        `- Recent 7-day topics are kept as a generated section inside ${path.join(memoryDir, "profile", "memory.md")}`,
+        `- Daily conversation memory: ${path.join(memoryDir, "daily", "YYYY", "MM", "YYYY-MM-DD.md")}`,
+        `- Daily memory promotion state: ${path.join(memoryDir, "daily", ".promotion-state.json")}`,
+        `- Skill memory: ${path.join(memoryDir, "skill-memory", "<namespace>.json")}`,
+        `- User skills: ${path.join(skillsDir, "<skill-id>", "skill.yaml")} and the skill's entry file`,
+        `- Saved notes: ${path.join(notesDir, "YYYY", "MM", "YYYY-MM-DD.md")}`,
+        `- Logs: ${path.join(logsDir, "conversations", "YYYY-MM-DD.jsonl")}, ${path.join(logsDir, "runs", "<run-id>.json")}, ${path.join(logsDir, "events.jsonl")}`,
+        "- For questions about Agent-Sin memory, notes, history, promotion, storage, or settings, use this map to decide where to inspect. The user does not need to provide exact paths.",
+    ];
+}
+async function buildReadOnlyFileContext(config, userText) {
+    const candidates = extractPathCandidates(userText);
+    const chunks = [];
+    let total = 0;
+    for (const candidate of candidates.slice(0, MAX_FILE_CONTEXT_ITEMS)) {
+        const chunk = await readPathContext(candidate, config);
+        if (!chunk) {
+            continue;
+        }
+        const remaining = MAX_FILE_CONTEXT_CHARS - total;
+        if (remaining <= 0) {
+            break;
+        }
+        const clipped = chunk.length > remaining ? `${chunk.slice(0, remaining)}\n... clipped ...` : chunk;
+        chunks.push(clipped);
+        total += clipped.length;
+    }
+    if (total < MAX_FILE_CONTEXT_CHARS) {
+        for (const chunk of await inferAgentSinContext(config, userText, candidates.length > 0)) {
+            const remaining = MAX_FILE_CONTEXT_CHARS - total;
+            if (remaining <= 0)
+                break;
+            const clipped = chunk.length > remaining ? `${chunk.slice(0, remaining)}\n... clipped ...` : chunk;
+            chunks.push(clipped);
+            total += clipped.length;
+        }
+    }
+    if (chunks.length === 0) {
+        return "";
+    }
+    return [
+        "Read-only filesystem context:",
+        `Working folder: ${config.workspace}`,
+        "Agent-Sin attached this context because the user's message mentioned local filesystem paths or Agent-Sin memory / notes / conversation history. No writes were performed.",
+        "Use this context directly. Do not say a separate skill is required to read these files.",
+        "",
+        ...chunks,
+    ].join("\n");
+}
+async function inferAgentSinContext(config, userText, hasExplicitPath) {
+    if (!shouldInferAgentSinContext(userText) && !hasExplicitPath) {
+        return [];
+    }
+    const chunks = [agentSinStorageMapContext(config)];
+    const text = userText.toLowerCase();
+    const asksProfileMemory = /(長期記憶|記憶|プロフィール|profile|memory\.md|user\.md|soul\.md|昇格|promotion|memory)/i.test(userText);
+    const asksDailyMemory = /(daily|日別|会話履歴|過去の会話|会話ログ|昨日|今日|一昨日|おととい|直近|最近|昇格|promotion)/i.test(userText);
+    const asksNotes = /(memo-list|memo|メモ|notes|ノート|保存先|保存場所)/i.test(userText);
+    if (asksProfileMemory) {
+        chunks.push(await existingFileContext(profileMemoryPath(config, "memory")));
+        chunks.push(await existingFileContext(profileMemoryPath(config, "user")));
+        chunks.push(await existingFileContext(profileMemoryPath(config, "soul")));
+        chunks.push(await existingFileContext(path.join(config.memory_dir, "daily", ".promotion-state.json")));
+    }
+    if (asksDailyMemory) {
+        chunks.push(await dailyMemoryContext(config, userText));
+    }
+    if (asksNotes && !text.includes("memory.md")) {
+        chunks.push(await notesContext(config));
+    }
+    return chunks.filter((chunk) => chunk.trim().length > 0);
+}
+function shouldInferAgentSinContext(userText) {
+    const domain = /(agent-sin|agentsin|長期記憶|記憶|memory|daily|日別|会話履歴|過去の会話|会話ログ|メモ|memo|notes|ノート|profile|soul|user\.md|昇格|promotion|保存先|保存場所)/i.test(userText);
+    const intent = /(見|読|確認|調べ|探|検索|一覧|どこ|どれ|何|内容|履歴|過去|昨日|今日|一昨日|おととい|直近|最近|昇格|保存|教えて|出して|知りたい|みれる|見れる|読める|read|find|search|where|list|show|inspect|check)/i.test(userText);
+    return domain && intent;
+}
+function agentSinStorageMapContext(config) {
+    return [
+        "<agent-sin-storage-map>",
+        `workspace: ${config.workspace}`,
+        `profile memory: ${path.join(config.memory_dir, "profile")}`,
+        `long-term memory: ${profileMemoryPath(config, "memory")}`,
+        `user profile: ${profileMemoryPath(config, "user")}`,
+        `AI profile: ${profileMemoryPath(config, "soul")}`,
+        `daily conversation memory: ${path.join(config.memory_dir, "daily")}`,
+        `daily promotion state: ${path.join(config.memory_dir, "daily", ".promotion-state.json")}`,
+        `notes: ${config.notes_dir}`,
+        `conversation logs: ${path.join(config.logs_dir, "conversations")}`,
+        "</agent-sin-storage-map>",
+    ].join("\n");
+}
+async function existingFileContext(file) {
+    if (isSensitivePath(file)) {
+        return "";
+    }
+    try {
+        const info = await stat(file);
+        if (!info.isFile())
+            return "";
+        return readFileContext(file);
+    }
+    catch {
+        return `<path path="${file}">\nnot found or not readable\n</path>`;
+    }
+}
+// Always-on context: the nightly-topic-knowledge skill builds a small index of
+// per-topic knowledge files; we surface the topic ids + one-line summaries on
+// every turn so the model can decide when to pull the full content via the
+// topic-knowledge-read skill. This is intentionally tiny (id + summary only)
+// so it costs almost nothing per turn.
+export async function buildTopicKnowledgeIndexContext(config) {
+    const file = path.join(config.memory_dir, "topic-knowledge", "index.json");
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch {
+        return "";
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return "";
+    }
+    const topics = Array.isArray(parsed.topics) ? parsed.topics : [];
+    const rows = [];
+    for (const entry of topics) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const tid = entry.topic_id;
+        if (typeof tid !== "string" || tid.length === 0)
+            continue;
+        const rawSummary = entry.summary;
+        const rawUpdated = entry.last_updated;
+        const summary = typeof rawSummary === "string" ? rawSummary.replace(/\s+/g, " ").trim() : "";
+        const clipped = summary.length > 140 ? `${summary.slice(0, 140)}…` : summary;
+        const updated = typeof rawUpdated === "string" ? rawUpdated.slice(0, 10) : "";
+        const tail = [clipped, updated ? `(${updated})` : ""].filter(Boolean).join(" ");
+        rows.push(`- ${tid}${tail ? `: ${tail}` : ""}`);
+    }
+    if (rows.length === 0)
+        return "";
+    return [
+        "<topic-knowledge-index>",
+        "Distilled per-topic knowledge from past conversations. Each item is a topic_id and a one-line summary.",
+        "Call the topic-knowledge-read skill with the relevant topic_ids when the user's question touches one of them; do not call it for every turn.",
+        ...rows,
+        "</topic-knowledge-index>",
+    ].join("\n");
+}
+async function dailyMemoryContext(config, userText) {
+    const targets = dailyMemoryTargetDates(userText);
+    const lines = [
+        "<daily-memory-context>",
+        `root: ${path.join(config.memory_dir, "daily")}`,
+    ];
+    for (const target of targets) {
+        const file = dailyConversationMemoryFile(config, target);
+        lines.push("", `target: ${localDateString(target)}`, await existingFileContext(file));
+    }
+    const latest = await listMarkdownFiles(path.join(config.memory_dir, "daily"), 5, 4);
+    lines.push("", "latest daily markdown files:");
+    lines.push(...(latest.length > 0 ? latest.map((file) => `- ${file}`) : ["(none)"]));
+    if (targets.length === 0 && latest[0]) {
+        lines.push("", `latest file preview: ${latest[0]}`, await filePreview(latest[0]));
+    }
+    lines.push("</daily-memory-context>");
+    return lines.join("\n");
+}
+function dailyMemoryTargetDates(userText) {
+    const dates = [];
+    const seen = new Set();
+    const add = (date) => {
+        const key = localDateString(date);
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        dates.push(date);
+    };
+    for (const match of userText.matchAll(/\b(\d{4})-(\d{2})-(\d{2})\b/g)) {
+        add(new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3])));
+    }
+    const now = new Date();
+    if (/(今日|today)/i.test(userText)) {
+        add(now);
+    }
+    if (/(昨日|前日|yesterday)/i.test(userText)) {
+        const date = new Date(now);
+        date.setDate(date.getDate() - 1);
+        add(date);
+    }
+    if (/(一昨日|おととい|day before yesterday)/i.test(userText)) {
+        const date = new Date(now);
+        date.setDate(date.getDate() - 2);
+        add(date);
+    }
+    return dates;
+}
+function localDateString(date) {
+    const yyyy = String(date.getFullYear());
+    const MM = String(date.getMonth() + 1).padStart(2, "0");
+    const dd = String(date.getDate()).padStart(2, "0");
+    return `${yyyy}-${MM}-${dd}`;
+}
+async function notesContext(config) {
+    const latest = await listMarkdownFiles(config.notes_dir, 8, 4);
+    return [
+        "<notes-context>",
+        `root: ${config.notes_dir}`,
+        "latest markdown files:",
+        ...(latest.length > 0 ? latest.map((file) => `- ${file}`) : ["(none)"]),
+        "</notes-context>",
+    ].join("\n");
+}
+async function buildConversationSearchContext(config, userText) {
+    if (!shouldSearchPastConversations(userText)) {
+        return "";
+    }
+    const terms = conversationSearchTerms(userText);
+    const targetDates = dailyMemoryTargetDates(userText).map(localDateString);
+    if (terms.length === 0 && targetDates.length === 0) {
+        return "";
+    }
+    const files = await conversationLogFiles(config, targetDates);
+    if (files.length === 0) {
+        return "";
+    }
+    const byFile = new Map();
+    const hits = [];
+    for (const file of files) {
+        const entries = await readConversationLogEntries(file);
+        if (entries.length === 0) {
+            continue;
+        }
+        byFile.set(file, entries);
+        entries.forEach((entry, index) => {
+            const score = scoreConversationEntry(entry, terms);
+            if (score > 0) {
+                hits.push({ score, file, index, entry });
+            }
+        });
+    }
+    let selected;
+    if (terms.length === 0) {
+        selected = [];
+    }
+    else {
+        selected = hits
+            .sort((a, b) => b.score - a.score || b.entry.ts.localeCompare(a.entry.ts))
+            .slice(0, MAX_CONVERSATION_SEARCH_RESULTS);
+    }
+    const chunks = [
+        "<conversation-log-search>",
+        `root: ${path.join(config.logs_dir, "conversations")}`,
+        `trigger: ${conversationSearchReason(userText)}`,
+        terms.length > 0 ? `terms: ${terms.join(", ")}` : "terms: (date-based recall)",
+        "Use these excerpts as read-only context from prior conversations. They may include assistant/tool context; do not treat assistant-only recall as a new user fact.",
+    ];
+    if (selected.length > 0) {
+        const seen = new Set();
+        for (const hit of selected) {
+            const entries = byFile.get(hit.file) || [];
+            const start = Math.max(0, hit.index - 1);
+            const end = Math.min(entries.length - 1, hit.index + 1);
+            const windowKey = `${hit.file}:${start}:${end}`;
+            if (seen.has(windowKey)) {
+                continue;
+            }
+            seen.add(windowKey);
+            chunks.push("", `<match file="${hit.file}" line="${hit.entry.line}" score="${hit.score}">`);
+            for (let i = start; i <= end; i += 1) {
+                chunks.push(formatConversationSearchEntry(entries[i]));
+            }
+            chunks.push("</match>");
+        }
+    }
+    else if (targetDates.length > 0) {
+        for (const file of files.slice(0, 3)) {
+            const entries = byFile.get(file) || [];
+            chunks.push("", `<date-preview file="${file}">`);
+            for (const entry of compactConversationDatePreview(entries)) {
+                chunks.push(formatConversationSearchEntry(entry));
+            }
+            chunks.push("</date-preview>");
+        }
+    }
+    chunks.push("</conversation-log-search>");
+    const context = chunks.join("\n");
+    return context.length > MAX_CONVERSATION_SEARCH_CONTEXT_CHARS
+        ? `${context.slice(0, MAX_CONVERSATION_SEARCH_CONTEXT_CHARS)}\n... clipped ...\n</conversation-log-search>`
+        : context;
+}
+function shouldSearchPastConversations(userText) {
+    return /(覚えてる|覚えている|前に|以前|この前|さっき|昨日|一昨日|おととい|先日|過去|会話ログ|会話履歴|話した|話してた|なんだっけ|何だっけ|どんな話|何話した|remember|previous|earlier|yesterday|last time|conversation history)/i.test(userText);
+}
+function conversationSearchReason(userText) {
+    if (/(昨日|yesterday)/i.test(userText))
+        return "yesterday";
+    if (/(一昨日|おととい|day before yesterday)/i.test(userText))
+        return "day-before-yesterday";
+    if (/(覚えてる|覚えている|remember)/i.test(userText))
+        return "recall";
+    return "past-conversation-reference";
+}
+function conversationSearchTerms(userText) {
+    const terms = [];
+    const seen = new Set();
+    const add = (term) => {
+        const normalized = normalizeConversationSearchTerm(term);
+        if (!normalized || seen.has(normalized) || conversationSearchStopwords().has(normalized)) {
+            return;
+        }
+        seen.add(normalized);
+        terms.push(normalized);
+    };
+    for (const match of userText.matchAll(/[A-Za-z0-9][A-Za-z0-9._+-]*/g)) {
+        add(match[0]);
+    }
+    for (const match of userText.matchAll(/[ぁ-んァ-ヶ一-龯ー]{2,}/g)) {
+        add(match[0]);
+    }
+    return terms.slice(0, 8);
+}
+function normalizeConversationSearchTerm(term) {
+    return term
+        .toLowerCase()
+        .replace(/^[\s"'`「『（(]+|[\s"'`」』）)、。.!?！？]+$/g, "")
+        .trim();
+}
+function conversationSearchStopwords() {
+    return new Set([
+        "この前",
+        "さっき",
+        "昨日",
+        "一昨日",
+        "おととい",
+        "先日",
+        "以前",
+        "過去",
+        "会話",
+        "会話ログ",
+        "会話履歴",
+        "話",
+        "話した",
+        "話してた",
+        "覚えてる",
+        "覚えている",
+        "なんだっけ",
+        "何だっけ",
+        "どんな話",
+        "何話した",
+        "それ",
+        "あれ",
+        "これ",
+        "件",
+        "について",
+        "して",
+        "した",
+        "です",
+        "ます",
+        "かな",
+        "いい",
+    ]);
+}
+async function conversationLogFiles(config, targetDates) {
+    const root = path.join(config.logs_dir, "conversations");
+    if (targetDates.length > 0) {
+        const candidates = targetDates
+            .flatMap((date) => adjacentDateStrings(date).map((key) => path.join(root, `${key}.jsonl`)));
+        const existing = [];
+        for (const file of candidates) {
+            try {
+                const info = await stat(file);
+                if (info.isFile())
+                    existing.push(file);
+            }
+            catch {
+                // ignore missing dates
+            }
+        }
+        return [...new Set(existing)];
+    }
+    try {
+        const entries = await readdir(root, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"))
+            .map((entry) => path.join(root, entry.name))
+            .sort((a, b) => b.localeCompare(a))
+            .slice(0, MAX_CONVERSATION_SEARCH_FILES);
+    }
+    catch {
+        return [];
+    }
+}
+function adjacentDateStrings(date) {
+    const [yyyy, MM, dd] = date.split("-").map((part) => Number.parseInt(part, 10));
+    const center = new Date(yyyy, MM - 1, dd);
+    return [-1, 0, 1].map((offset) => {
+        const next = new Date(center);
+        next.setDate(next.getDate() + offset);
+        return localDateString(next);
+    });
+}
+async function readConversationLogEntries(file) {
+    let raw = "";
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch {
+        return [];
+    }
+    return raw
+        .split(/\r?\n/)
+        .map((line, index) => parseConversationLogLine(file, index + 1, line))
+        .filter((entry) => Boolean(entry));
+}
+function parseConversationLogLine(file, line, raw) {
+    if (!raw.trim()) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        const content = typeof parsed.content === "string" ? parsed.content : "";
+        if (!content.trim()) {
+            return null;
+        }
+        return {
+            file,
+            line,
+            ts: typeof parsed.ts === "string" ? parsed.ts : "",
+            source: typeof parsed.source === "string" ? parsed.source : "",
+            role: typeof parsed.role === "string" ? parsed.role : "",
+            content: normalizeConversationLogContent(content, typeof parsed.role === "string" ? parsed.role : ""),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeConversationLogContent(content, role) {
+    const trimmed = content.trim();
+    if (role === "assistant") {
+        const parsed = parseJsonObject(trimmed);
+        if (parsed && typeof parsed.reply === "string") {
+            const calls = Array.isArray(parsed.skill_calls) ? parsed.skill_calls : [];
+            const callText = calls
+                .map((call) => {
+                if (!call || typeof call !== "object")
+                    return "";
+                const record = call;
+                return typeof record.id === "string" ? `skill:${record.id}` : "";
+            })
+                .filter(Boolean)
+                .join(", ");
+            return [parsed.reply.trim(), callText].filter(Boolean).join("\n");
+        }
+    }
+    if (role === "tool") {
+        const fenced = trimmed.match(/```skill-result\s*([\s\S]*?)```/i);
+        const parsed = parseJsonObject(fenced?.[1]?.trim() || trimmed);
+        if (parsed && typeof parsed.summary === "string") {
+            return parsed.summary.trim();
+        }
+    }
+    return scrubConversationSearchText(trimmed);
+}
+function scoreConversationEntry(entry, terms) {
+    const content = entry.content.toLowerCase();
+    let score = 0;
+    for (const term of terms) {
+        if (!term)
+            continue;
+        if (content.includes(term)) {
+            score += entry.role === "user" ? 4 : 2;
+            if (/^[a-z0-9._+-]+$/.test(term)) {
+                score += 1;
+            }
+        }
+    }
+    return score;
+}
+function compactConversationDatePreview(entries) {
+    const userEntries = entries.filter((entry) => entry.role === "user");
+    if (userEntries.length <= MAX_CONVERSATION_SEARCH_RESULTS) {
+        return userEntries;
+    }
+    const head = userEntries.slice(0, 3);
+    const tail = userEntries.slice(-3);
+    return [...head, ...tail];
+}
+function formatConversationSearchEntry(entry) {
+    const timestamp = entry.ts ? entry.ts.replace("T", " ").replace(/\.\d{3}Z$/, "Z") : "";
+    const label = [timestamp, entry.source, entry.role].filter(Boolean).join(" ");
+    return [`- ${label}`, clipConversationSearchText(entry.content)].join("\n  ");
+}
+function clipConversationSearchText(text) {
+    const scrubbed = scrubConversationSearchText(text).replace(/\n/g, "\n  ");
+    if (scrubbed.length <= MAX_CONVERSATION_SEARCH_TURN_CHARS) {
+        return scrubbed;
+    }
+    return `${scrubbed.slice(0, MAX_CONVERSATION_SEARCH_TURN_CHARS)}\n  ... clipped ...`;
+}
+function scrubConversationSearchText(text) {
+    return text
+        .replace(/\/Users\/[^\s)]+/g, "[local path]")
+        .replace(/\s+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+function extractPathCandidates(text) {
+    const seen = new Set();
+    const candidates = [];
+    for (const match of text.matchAll(PATH_CANDIDATE_PATTERN)) {
+        const normalized = normalizeMentionedPath(match[0]);
+        if (!normalized || seen.has(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        candidates.push(normalized);
+    }
+    return candidates;
+}
+function normalizeMentionedPath(raw) {
+    let value = raw
+        .trim()
+        .replace(/[。、，,!?;:)\]}]+$/g, "");
+    if (!value) {
+        return "";
+    }
+    if (value.startsWith("Users/")) {
+        value = `/${value}`;
+    }
+    if (value.startsWith("~/")) {
+        value = path.join(os.homedir(), value.slice(2));
+    }
+    if (!path.isAbsolute(value)) {
+        return "";
+    }
+    return path.normalize(value);
+}
+async function readPathContext(candidate, config) {
+    if (containsDatePlaceholders(candidate)) {
+        return readPlaceholderPathContext(candidate);
+    }
+    if (isSensitivePath(candidate)) {
+        return `<path path="${candidate}">\nskipped: sensitive file path\n</path>`;
+    }
+    try {
+        const info = await stat(candidate);
+        if (info.isDirectory()) {
+            return await readDirectoryContext(candidate);
+        }
+        if (info.isFile()) {
+            return await readFileContext(candidate);
+        }
+        return `<path path="${candidate}">\nskipped: unsupported filesystem entry\n</path>`;
+    }
+    catch {
+        const relative = path.resolve(config.workspace, candidate);
+        if (relative !== candidate) {
+            try {
+                const info = await stat(relative);
+                if (info.isFile() && !isSensitivePath(relative))
+                    return await readFileContext(relative);
+                if (info.isDirectory())
+                    return await readDirectoryContext(relative);
+            }
+            catch {
+                // fall through to missing path context
+            }
+        }
+        return `<path path="${candidate}">\nnot found or not readable\n</path>`;
+    }
+}
+function containsDatePlaceholders(value) {
+    return /\bY{4}\b|\bM{2}\b|\bD{2}\b/.test(value);
+}
+async function readPlaceholderPathContext(candidate) {
+    const base = placeholderBasePath(candidate);
+    if (!base || isSensitivePath(base)) {
+        return `<path-pattern path="${candidate}">\nskipped: unsupported placeholder path\n</path-pattern>`;
+    }
+    try {
+        const info = await stat(base);
+        if (!info.isDirectory()) {
+            return `<path-pattern path="${candidate}">\nbase is not a directory: ${base}\n</path-pattern>`;
+        }
+    }
+    catch {
+        return `<path-pattern path="${candidate}">\nbase not found or not readable: ${base}\n</path-pattern>`;
+    }
+    const files = await listMarkdownFiles(base, 8, 4);
+    const latest = files[0];
+    const lines = [
+        `<path-pattern path="${candidate}">`,
+        `base: ${base}`,
+        "matching markdown files, newest path first:",
+        ...(files.length > 0 ? files.map((file) => `- ${file}`) : ["(none)"]),
+    ];
+    if (latest && !isSensitivePath(latest)) {
+        lines.push("", `latest file preview: ${latest}`, await filePreview(latest));
+    }
+    lines.push("</path-pattern>");
+    return lines.join("\n");
+}
+function placeholderBasePath(candidate) {
+    const index = candidate.search(/(?:^|\/)(?:Y{4}|M{2}|D{2})(?:\/|\.|-|$)/);
+    if (index < 0) {
+        return "";
+    }
+    const base = candidate.slice(0, index).replace(/\/+$/g, "");
+    return base || path.parse(candidate).root;
+}
+async function listMarkdownFiles(root, limit, maxDepth) {
+    const files = [];
+    async function walk(dir, depth) {
+        if (files.length >= limit || depth < 0) {
+            return;
+        }
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            if (files.length >= limit)
+                break;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full, depth - 1);
+            }
+            else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
+                files.push(full);
+            }
+        }
+    }
+    await walk(root, maxDepth);
+    return files.sort((a, b) => b.localeCompare(a)).slice(0, limit);
+}
+async function readDirectoryContext(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const names = entries
+        .sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name))
+        .slice(0, MAX_DIRECTORY_ENTRIES)
+        .map((entry) => `${entry.name}${entry.isDirectory() ? "/" : ""}`);
+    const more = entries.length > names.length ? `\n... ${entries.length - names.length} more entries ...` : "";
+    return [`<directory path="${dir}">`, ...names, `${more}</directory>`].join("\n");
+}
+async function readFileContext(file) {
+    return [`<file path="${file}">`, await filePreview(file), "</file>"].join("\n");
+}
+async function filePreview(file) {
+    const data = await readFile(file);
+    if (data.includes(0)) {
+        return "skipped: binary file";
+    }
+    const text = data.toString("utf8");
+    return text.length > MAX_SINGLE_FILE_CHARS ? `${text.slice(0, MAX_SINGLE_FILE_CHARS)}\n... clipped ...` : text;
+}
+function isSensitivePath(file) {
+    const normalized = file.toLowerCase();
+    const base = path.basename(normalized);
+    if (base === ".env" ||
+        base.startsWith(".env.") ||
+        /\.(pem|key|p12|pfx|mobileprovision)$/i.test(base)) {
+        return true;
+    }
+    return /(^|\/)(\.ssh|\.gnupg|keychains)(\/|$)/i.test(normalized) ||
+        /(secret|token|credential|password|cookie|authorization)/i.test(normalized);
+}
 function skillCallKey(call) {
     return `${call.id}:${stableStringify(call.args)}`;
 }
+function normalizeSkillCallsForExecution(calls) {
+    const restartCall = calls.find((call) => call.id === SERVICE_RESTART_SKILL_ID);
+    if (!restartCall) {
+        return { calls, changed: false };
+    }
+    const normalized = { id: SERVICE_RESTART_SKILL_ID, args: {} };
+    const changed = calls.length !== 1 || stableStringify(restartCall.args) !== "{}";
+    return { calls: [normalized], changed };
+}
 function emptyChatFallback() {
     return l("I could not produce a reply. Please send it once more.", "返答を作れませんでした。もう一度送ってください。");
 }
 function emptyReplyRetryPrompt() {
-    return "Your previous response was empty. Use the user's latest message and the conversation context to produce a short, useful reply now in the user's language. If a skill call is required, emit a valid skill-call block. If build mode is required, include a short visible confirmation question and the hidden build-suggestion block. Do not return an empty response.";
+    return [
+        "Your previous response was empty.",
+        "Return exactly one JSON object using the required Agent-Sin response envelope.",
+        "Use the user's latest message and conversation context to produce a short, useful reply now in the user's language.",
+        "If a skill call is required, put it in skill_calls. If build mode is required because the user explicitly asked to create or fix now, put the handoff in build_suggestion.",
+        "Do not return an empty response.",
+    ].join(" ");
 }
-function shouldRetryEmptyAssistantReply(assistantText, buildSuggestion) {
-    return !buildSuggestion && parseSkillCalls(assistantText).length === 0 && stripSkillCalls(assistantText).trim().length === 0;
+function shouldRetryEmptyAssistantReply(output, hasBufferedSkillOutput = false) {
+    // When skills have already produced visible output, an empty reply is a
+    // valid signal that the model wants to passthrough that output as-is.
+    // Don't treat it as a broken response and don't retry.
+    if (hasBufferedSkillOutput)
+        return false;
+    return !output.buildSuggestion && output.skillCalls.length === 0 && output.reply.trim().length === 0;
 }
 function stableStringify(value) {
     if (value === null || typeof value !== "object") {
@@ -718,20 +1632,136 @@ function stableStringify(value) {
     const entries = Object.entries(value).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
     return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
 }
+function parseAssistantOutput(text) {
+    const envelope = parseAssistantEnvelope(text);
+    if (envelope) {
+        const reply = typeof envelope.reply === "string" ? envelope.reply : "";
+        const skillCalls = parseEnvelopeSkillCalls(envelope.skill_calls);
+        const buildSuggestion = parseEnvelopeBuildSuggestion(envelope.build_suggestion);
+        return {
+            reply,
+            skillCalls,
+            buildSuggestion,
+            rawText: text,
+            structured: true,
+            controlOnlyText: formatAssistantEnvelope({
+                reply: "",
+                skill_calls: skillCalls,
+                build_suggestion: buildSuggestion,
+            }),
+        };
+    }
+    if (looksLikeStructuredEnvelopeAttempt(text)) {
+        return {
+            reply: "",
+            skillCalls: [],
+            buildSuggestion: null,
+            rawText: text,
+            structured: false,
+            controlOnlyText: "",
+        };
+    }
+    const buildSuggestion = parseBuildSuggestion(text);
+    const skillCalls = parseSkillCalls(text);
+    return {
+        reply: stripInternalControlBlocks(text),
+        skillCalls,
+        buildSuggestion,
+        rawText: text,
+        structured: false,
+        controlOnlyText: [
+            skillCalls.length > 0 ? extractSkillCallBlocks(text) : "",
+            buildSuggestion ? formatBuildSuggestionBlock(buildSuggestion) : "",
+        ].filter(Boolean).join("\n"),
+    };
+}
+function looksLikeStructuredEnvelopeAttempt(text) {
+    const trimmed = text.trim();
+    return trimmed.startsWith("{") || /^```json\s*\n/i.test(trimmed) || /^```\s*\n\s*\{/i.test(trimmed);
+}
+function parseAssistantEnvelope(text) {
+    const parsed = parseJsonObject(text.trim());
+    if (parsed && isAssistantEnvelopeLike(parsed)) {
+        return parsed;
+    }
+    const fenced = extractSingleJsonFence(text.trim());
+    if (!fenced) {
+        return null;
+    }
+    const fencedParsed = parseJsonObject(fenced);
+    return fencedParsed && isAssistantEnvelopeLike(fencedParsed) ? fencedParsed : null;
+}
+function isAssistantEnvelopeLike(value) {
+    return "reply" in value || "skill_calls" in value || "build_suggestion" in value;
+}
+function parseJsonObject(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function extractSingleJsonFence(text) {
+    const match = text.match(/^```(?:json)?\s*\n([\s\S]*?)\n```\s*$/i);
+    return match ? match[1].trim() : null;
+}
+function parseEnvelopeSkillCalls(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const calls = [];
+    for (const item of value) {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            continue;
+        }
+        const record = item;
+        if (typeof record.id !== "string" || !record.id.trim()) {
+            continue;
+        }
+        const rawArgs = record.args;
+        const args = rawArgs && typeof rawArgs === "object" && !Array.isArray(rawArgs)
+            ? rawArgs
+            : {};
+        calls.push({ id: record.id, args });
+    }
+    return calls;
+}
+function parseEnvelopeBuildSuggestion(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    if (record.type !== "create" && record.type !== "edit") {
+        return null;
+    }
+    const skillId = sanitizeSuggestedSkillId(String(record.skill_id || ""));
+    if (!skillId) {
+        return null;
+    }
+    return {
+        type: record.type,
+        skill_id: skillId,
+        reason: typeof record.reason === "string" ? record.reason.slice(0, 240) : undefined,
+    };
+}
 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 +1770,368 @@ 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));
+    return mergeInternalBlocks([
+        ...findFencedInternalControlBlocks(text, wanted),
+        ...findBareInternalControlBlocks(text, wanted),
+    ]);
+}
+function findFencedInternalControlBlocks(text, wanted) {
+    const blocks = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        const start = nextFenceStart(text, cursor);
+        if (start < 0)
+            break;
+        const block = readFencedInternalControlBlock(text, start, wanted);
+        if (block) {
+            blocks.push(block);
+            cursor = block.end;
+        }
+        else {
+            cursor = start + 1;
+        }
+    }
+    return blocks;
+}
+function readFencedInternalControlBlock(text, fenceStart, wanted) {
+    const fenceChar = text[fenceStart];
+    if (fenceChar !== "`" && fenceChar !== "~")
         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)
+    const fenceLength = countRepeatedChars(text, fenceStart, fenceChar);
+    if (fenceLength < 3)
+        return null;
+    const openingLineEnd = findLineContentEnd(text, fenceStart);
+    const openingLineFullEnd = findLineFullEnd(text, openingLineEnd);
+    const info = text.slice(fenceStart + fenceLength, openingLineEnd).trim();
+    const inlineName = info ? normalizeInternalBlockName(info) : "";
+    let name = inlineName;
+    let payloadStart = openingLineFullEnd;
+    if (name && !wanted.has(name)) {
+        return null;
+    }
+    if (!name) {
+        const labelLineEnd = findLineContentEnd(text, payloadStart);
+        if (labelLineEnd <= payloadStart && payloadStart >= text.length) {
             return null;
-        return {
-            type,
-            skill_id: skillId,
-            reason: typeof parsed.reason === "string" ? parsed.reason.slice(0, 240) : undefined,
-        };
+        }
+        const splitName = normalizeInternalBlockName(text.slice(payloadStart, labelLineEnd).trim());
+        if (!wanted.has(splitName)) {
+            return null;
+        }
+        name = splitName;
+        payloadStart = findLineFullEnd(text, labelLineEnd);
     }
-    catch {
+    const close = findClosingFence(text, payloadStart, fenceChar, fenceLength);
+    const payloadEnd = close ? close.start : text.length;
+    const blockEnd = close ? close.end : text.length;
+    const lineStart = findLineStart(text, fenceStart);
+    const leading = text.slice(lineStart, fenceStart);
+    const blockStart = leading.trim() ? fenceStart : lineStart;
+    return {
+        name,
+        payload: text.slice(payloadStart, payloadEnd).trim(),
+        start: blockStart,
+        end: blockEnd,
+    };
+}
+function findBareInternalControlBlocks(text, wanted) {
+    const lines = splitLinesWithOffsets(text);
+    const blocks = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        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 nextFenceStart(text, start) {
+    const backtick = text.indexOf("```", start);
+    const tilde = text.indexOf("~~~", start);
+    if (backtick < 0)
+        return tilde;
+    if (tilde < 0)
+        return backtick;
+    return Math.min(backtick, tilde);
+}
+function countRepeatedChars(text, start, char) {
+    let end = start;
+    while (end < text.length && text[end] === char) {
+        end += 1;
+    }
+    return end - start;
+}
+function findLineStart(text, offset) {
+    const newline = text.lastIndexOf("\n", Math.max(0, offset - 1));
+    return newline >= 0 ? newline + 1 : 0;
+}
+function findLineContentEnd(text, start) {
+    const newline = text.indexOf("\n", start);
+    const end = newline >= 0 ? newline : text.length;
+    return end > start && text[end - 1] === "\r" ? end - 1 : end;
+}
+function findLineFullEnd(text, contentEnd) {
+    if (contentEnd < text.length && text[contentEnd] === "\r" && text[contentEnd + 1] === "\n") {
+        return contentEnd + 2;
+    }
+    if (contentEnd < text.length && text[contentEnd] === "\n") {
+        return contentEnd + 1;
+    }
+    if (contentEnd + 1 < text.length && text[contentEnd + 1] === "\n" && text[contentEnd] === "\r") {
+        return contentEnd + 2;
+    }
+    return contentEnd;
+}
+function findClosingFence(text, start, fenceChar, minLength) {
+    let lineStart = start;
+    while (lineStart < text.length) {
+        const lineEnd = findLineContentEnd(text, lineStart);
+        const trimmed = text.slice(lineStart, lineEnd).trim();
+        if (trimmed.length >= minLength &&
+            [...trimmed].every((item) => item === fenceChar)) {
+            return { start: lineStart, end: findLineFullEnd(text, lineEnd) };
+        }
+        const next = findLineFullEnd(text, lineEnd);
+        if (next <= lineStart)
+            break;
+        lineStart = next;
+    }
+    return null;
+}
+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 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 formatAssistantEnvelope(args) {
+    return safeJson({
+        reply: args.reply,
+        skill_calls: args.skill_calls || [],
+        build_suggestion: args.build_suggestion || null,
+    });
+}
+function formatBuildSuggestionBlock(suggestion) {
+    return [
+        "```agent-sin-build-suggestion",
+        safeJson({
+            type: suggestion.type,
+            skill_id: suggestion.skill_id,
+            reason: suggestion.reason,
+        }),
+        "```",
+    ].join("\n");
+}
+function resolveDirectSkillCall(skills, userText, preferredSkillId) {
+    const normalizedText = normalizeSkillTrigger(userText);
+    if (!normalizedText) {
+        return null;
+    }
+    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
@@ -779,11 +2142,14 @@ function sanitizeSuggestedSkillId(raw) {
         .replace(/^-+|-+$/g, "")
         .slice(0, 48);
 }
-export function toolResultJson(id, status, summary, saved = [], data) {
+export function toolResultJson(id, status, summary, saved = [], data, notes) {
     const payload = { id, status, summary, saved };
     if (data !== undefined) {
         payload.data = data;
     }
+    if (notes && notes.length > 0) {
+        payload.notes = notes;
+    }
     return ["```skill-result", JSON.stringify(payload), "```"].join("\n");
 }
 export function toAiMessages(history, multimodalTurn) {