agent-sin 0.1.12 → 0.1.16

package/dist/core/daily-memory-promotion.js

@@ -7,8 +7,17 @@ import { appendProfileMemory, profileMemoryPath, readProfileMemoryFiles, } from
 import { l } from "./i18n.js";
 const MAX_DAILY_CHARS = 24000;
 const MAX_MEMORY_CHARS = 12000;
-const MAX_PROMOTION_ITEMS = 3;
+const MAX_PROMOTION_ITEMS = 5;
 const MAX_ITEM_CHARS = 500;
+const RECENT_TOPIC_DAYS = 7;
+const MAX_RECENT_TOPIC_ITEMS = 50;
+const MAX_RECENT_TOPIC_CHARS = 180;
+const MAX_RECENT_TOPIC_DAILY_CHARS = 5000;
+const MAX_RECENT_TOPIC_INPUT_CHARS = 36000;
+const MAX_MEMORY_DIFF_CHARS = 12000;
+const MAX_RECENT_TOPIC_USER_ENTRY_CHARS = 360;
+const MAX_RECENT_TOPIC_ASSISTANT_ENTRY_CHARS = 420;
+const MAX_RECENT_TOPIC_TOOL_ENTRY_CHARS = 260;
 export async function maybePromoteDailyMemory(config, options = {}) {
     let result;
     try {
@@ -68,9 +77,12 @@ export async function promoteDailyMemory(config, options = {}) {
         };
     }
     const profile = await readProfileMemoryFiles(config);
+    const memoryFile = profileMemoryPath(config, "memory");
+    const memoryBefore = await readTextIfExists(memoryFile);
+    const promotionDaily = dailyMemoryPromotionSource(daily);
     const response = await requestPromotionItems(config, {
         date,
-        daily,
+        daily: promotionDaily,
         existingMemory: profile.memory,
         modelId: options.modelId || config.chat_model_id,
     });
@@ -88,6 +100,13 @@ export async function promoteDailyMemory(config, options = {}) {
         await appendProfileMemory(config, "memory", formatPromotedMemoryEntry(date, items), options.now || new Date());
         await consolidateMemoryFile(config, options.modelId || config.chat_model_id, options.eventSource || "chat");
     }
+    if (!options.dryRun) {
+        await refreshRecentTopicsSection(config, {
+            endDate: date,
+            modelId: options.modelId || config.chat_model_id,
+            eventSource: options.eventSource || "chat",
+        });
+    }
     if (!options.dryRun) {
         state.dates[date] = {
             hash,
@@ -97,6 +116,17 @@ export async function promoteDailyMemory(config, options = {}) {
         };
         await writePromotionState(config, state);
     }
+    if (!options.dryRun) {
+        await appendMemoryPromotionDiffLog(config, {
+            date,
+            file: memoryFile,
+            before: memoryBefore,
+            after: await readTextIfExists(memoryFile),
+            items,
+            status: items.length > 0 ? "promoted" : "reviewed",
+            eventSource: options.eventSource || "chat",
+        });
+    }
     return {
         status: items.length > 0 ? "promoted" : "reviewed",
         date,
@@ -105,6 +135,116 @@ export async function promoteDailyMemory(config, options = {}) {
         message: items.length > 0 ? `promoted ${items.length} item(s) from ${date}` : `no long-term memory items: ${date}`,
     };
 }
+async function appendMemoryPromotionDiffLog(config, input) {
+    const diff = formatMemoryDiff(input.before, input.after);
+    await appendEventLog(config, {
+        level: "info",
+        source: input.eventSource,
+        event: "memory_promotion_diff",
+        message: diff
+            ? `memory.md diff recorded for ${input.date}`
+            : `memory.md unchanged for ${input.date}`,
+        details: {
+            date: input.date,
+            status: input.status,
+            file: input.file,
+            promoted_items: input.items,
+            changed: diff.length > 0,
+            diff,
+        },
+    });
+}
+function formatMemoryDiff(before, after) {
+    if (normalizeForCompare(before) === normalizeForCompare(after)) {
+        return "";
+    }
+    const raw = unifiedLineDiff(before, after);
+    return raw.length <= MAX_MEMORY_DIFF_CHARS
+        ? raw
+        : `${raw.slice(0, MAX_MEMORY_DIFF_CHARS)}\n... diff truncated ...`;
+}
+function unifiedLineDiff(before, after) {
+    const beforeLines = before.split(/\r?\n/);
+    const afterLines = after.split(/\r?\n/);
+    const operations = lineDiffOperations(beforeLines, afterLines);
+    return [
+        "--- memory.md before",
+        "+++ memory.md after",
+        "@@",
+        ...operations.map((op) => `${op.kind}${op.text}`),
+    ].join("\n");
+}
+function lineDiffOperations(beforeLines, afterLines) {
+    const rows = beforeLines.length + 1;
+    const cols = afterLines.length + 1;
+    if (rows * cols > 20000) {
+        return [
+            { kind: "-", text: `<${beforeLines.length} lines before>` },
+            { kind: "+", text: `<${afterLines.length} lines after>` },
+        ];
+    }
+    const dp = Array.from({ length: rows }, () => Array(cols).fill(0));
+    for (let i = beforeLines.length - 1; i >= 0; i -= 1) {
+        for (let j = afterLines.length - 1; j >= 0; j -= 1) {
+            dp[i][j] = beforeLines[i] === afterLines[j]
+                ? dp[i + 1][j + 1] + 1
+                : Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    }
+    const operations = [];
+    let i = 0;
+    let j = 0;
+    while (i < beforeLines.length && j < afterLines.length) {
+        if (beforeLines[i] === afterLines[j]) {
+            operations.push({ kind: " ", text: beforeLines[i] });
+            i += 1;
+            j += 1;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1]) {
+            operations.push({ kind: "-", text: beforeLines[i] });
+            i += 1;
+        }
+        else {
+            operations.push({ kind: "+", text: afterLines[j] });
+            j += 1;
+        }
+    }
+    while (i < beforeLines.length) {
+        operations.push({ kind: "-", text: beforeLines[i] });
+        i += 1;
+    }
+    while (j < afterLines.length) {
+        operations.push({ kind: "+", text: afterLines[j] });
+        j += 1;
+    }
+    return compactDiffContext(operations);
+}
+function compactDiffContext(operations) {
+    const keep = new Set();
+    for (let i = 0; i < operations.length; i += 1) {
+        if (operations[i].kind === " ") {
+            continue;
+        }
+        for (let j = Math.max(0, i - 2); j <= Math.min(operations.length - 1, i + 2); j += 1) {
+            keep.add(j);
+        }
+    }
+    const compacted = [];
+    let skipped = false;
+    for (let i = 0; i < operations.length; i += 1) {
+        if (keep.has(i)) {
+            if (skipped) {
+                compacted.push({ kind: " ", text: "..." });
+                skipped = false;
+            }
+            compacted.push(operations[i]);
+        }
+        else {
+            skipped = true;
+        }
+    }
+    return compacted;
+}
 export function parseDailyMemoryPromotionResponse(text) {
     const jsonText = extractJson(text);
     let parsed;
@@ -135,6 +275,26 @@ export function parseDailyMemoryPromotionResponse(text) {
         .filter(Boolean)
         .slice(0, MAX_PROMOTION_ITEMS);
 }
+function dailyMemoryPromotionSource(daily) {
+    const note = [
+        "<!-- Promotion note:",
+        "Assistant and tool entries are included for context.",
+        "Promote a long-term fact only when it is supported by the target-date exchange, preferably by direct user wording.",
+        "Do not promote details that appear only because the assistant recalled or summarized an earlier date.",
+        "-->",
+    ].join("\n");
+    if (!daily.trim()) {
+        return daily;
+    }
+    const lines = daily.split(/\r?\n/);
+    const titleIndex = lines.findIndex((line) => /^#\s+\S/.test(line.trim()));
+    if (titleIndex < 0) {
+        return `${note}\n\n${daily}`;
+    }
+    const next = [...lines];
+    next.splice(titleIndex + 1, 0, "", note);
+    return next.join("\n");
+}
 async function requestPromotionItems(config, input) {
     try {
         const response = await getAiProvider()(config, {
@@ -145,22 +305,29 @@ async function requestPromotionItems(config, input) {
                     role: "system",
                     content: [
                         "You are Agent-Sin's long-term memory curator. memory.md is a long-term note used to understand the user deeply and keep conversations smooth.",
-                        "Promote only observations from daily conversation memory that directly help understand the user. Be strict; if unsure, output nothing. Maximum 3 items, zero is fine.",
+                        "Promote observations and meta-level inferences from daily conversation memory that help understand the user across future conversations. Lean toward promoting when an observation is reasonably supported by user wording; skip only when truly unclear or noisy. Maximum 5 items, zero is fine.",
+                        "Assistant responses may be used as context, but do not promote a fact whose only support is an assistant response, tool output, or system context.",
+                        "A promoted fact must be grounded in the target-date exchange. Prefer direct user wording; assistant summaries are only supporting context.",
+                        "If the user asks whether you remember a previous conversation, do not treat the assistant's recall as a new fact for the target date.",
+                        "Casual conversation can be high-signal. Do not save raw small talk; extract the durable preference, recurring interest, concern, lifestyle pattern, decision criterion, or work/personal context it implies.",
+                        "When support is light, avoid overclaiming. Prefer cautious wording such as 'appears interested in', 'is concerned about', 'often discusses', or 'may prefer' when that is more accurate than a hard fact.",
                         "Write each item in the same language as the source daily-conversation.md content.",
                         "Keep only items directly about the user:",
                         "- The user's role, experience, interests, and personal context",
                         "- Communication tendencies, preferred style, disliked expressions, and decision habits",
                         "- Values, beliefs, and things the user considers important",
+                        "- Lifestyle, health, learning, media, hobby, and product interests when useful for future conversations",
+                        "- Meta-level patterns inferred from repeated or strongly worded casual chat",
                         "- Notification/channel preferences, subscribed media, preferred formats",
                         "- Stable interests or areas the user is not interested in",
                         "Never keep operating rules, skill settings, or work logs:",
                         "- Schedules, notification timing, notification destinations, filters, limits, or other skill behavior settings",
                         "- Action rules tied to individual emails, files, or usernames",
                         "- Recent task work, commits, fixes, or implementation steps",
-                        "- Same-day chat, impressions, status updates, progress, mood, health, or weather",
+                        "- Raw same-day events, one-off impressions, transient status updates, or casual chat with no durable signal",
                         "- Tool output, logs, code snippets, or URL lists",
                         "- Content with the same meaning as existing memory.md",
-                        "- Secrets, API keys, tokens, sensitive finance/family information, or information identifying other people",
+                        "- Secrets, API keys, tokens, detailed or sensitive health/finance/family information, or information identifying other people. Abstract sensitive topics to broad concerns or habits when useful.",
                         "Output rules: each item must be one generic sentence or fact. Do not include dates, ongoing wording, or 'today I...' phrasing.",
                         'Output JSON only: {"items":[{"text":"..."}]}. If nothing qualifies, return {"items":[]}.',
                     ].join("\n"),
@@ -198,15 +365,383 @@ function formatPromotedMemoryEntry(date, items) {
         ...items.map((item) => `- ${item}`),
     ].join("\n");
 }
+export async function refreshRecentTopicsSection(config, input) {
+    try {
+        const targetDate = input.endDate;
+        const targetDaily = await readTextIfExists(dailyMemoryFileForDate(config, targetDate));
+        const dailyHasContent = !!targetDaily.replace(/^# .+$/m, "").trim();
+        const file = profileMemoryPath(config, "memory");
+        const original = await readTextIfExists(file);
+        const existingTopics = parseDatedTopicsFromSection(original, targetDate);
+        const prunedExisting = pruneStaleTopics(existingTopics, targetDate, RECENT_TOPIC_DAYS);
+        let mergedTopics = prunedExisting;
+        let appended = 0;
+        if (dailyHasContent) {
+            const compacted = compactDailyMemoryForRecentTopics(targetDaily);
+            const newTopics = await requestRecentTopicsForDate(config, {
+                targetDate,
+                dailyContent: compacted,
+                existingTopics: prunedExisting,
+                modelId: input.modelId,
+            });
+            appended = newTopics.length;
+            mergedTopics = mergeDatedTopics(prunedExisting, newTopics, targetDate);
+        }
+        if (mergedTopics.length === 0 && existingTopics.length === 0) {
+            return;
+        }
+        const next = upsertRecentTopicsSection(original, targetDate, mergedTopics);
+        if (normalizeForCompare(next) === normalizeForCompare(original)) {
+            return;
+        }
+        await writeFile(file, next, "utf8");
+        await appendEventLog(config, {
+            level: "info",
+            source: input.eventSource,
+            event: "recent_topics_refreshed",
+            message: `recent topics refreshed through ${targetDate}`,
+            details: {
+                file,
+                end_date: targetDate,
+                items: mergedTopics.length,
+                appended,
+                pruned: existingTopics.length - prunedExisting.length,
+            },
+        });
+    }
+    catch (error) {
+        await appendEventLog(config, {
+            level: "warn",
+            source: input.eventSource,
+            event: "recent_topics_refresh_failed",
+            message: error instanceof Error ? error.message : String(error),
+            details: { end_date: input.endDate },
+        });
+    }
+}
+function parseDatedTopicsFromSection(original, fallbackDate) {
+    const lines = original.split(/\r?\n/);
+    const start = lines.findIndex((line) => recentTopicsHeading(line));
+    if (start < 0) {
+        return [];
+    }
+    let end = start + 1;
+    while (end < lines.length && !/^#{1,6}\s+\S/.test(lines[end].trim())) {
+        end += 1;
+    }
+    const body = lines.slice(start + 1, end);
+    const topics = [];
+    const seen = new Set();
+    for (const raw of body) {
+        const line = raw.replace(/^[-*・]\s*/, "").trim();
+        if (!line || line.startsWith("<!--"))
+            continue;
+        const dated = line.match(/^(\d{4}-\d{2}-\d{2})\s*[:：]\s*(.+)$/);
+        const date = dated ? dated[1] : fallbackDate;
+        const text = cleanRecentTopic(dated ? dated[2] : line);
+        if (!text)
+            continue;
+        const key = normalizeForDedupe(text);
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        topics.push({ date, text });
+    }
+    return topics;
+}
+function pruneStaleTopics(topics, targetDate, days) {
+    const cutoff = addDays(dateFromLocalDateString(targetDate), -(days - 1));
+    const cutoffKey = localDateString(cutoff);
+    return topics.filter((topic) => topic.date >= cutoffKey);
+}
+function mergeDatedTopics(existing, incoming, targetDate) {
+    const byKey = new Map();
+    const order = [];
+    for (const topic of existing) {
+        const key = normalizeForDedupe(topic.text);
+        if (!key || byKey.has(key))
+            continue;
+        byKey.set(key, topic);
+        order.push(key);
+    }
+    for (const topic of incoming) {
+        const key = normalizeForDedupe(topic.text);
+        if (!key || byKey.has(key))
+            continue;
+        byKey.set(key, { date: topic.date || targetDate, text: topic.text });
+        order.push(key);
+    }
+    const merged = order.map((key) => byKey.get(key)).filter(Boolean);
+    merged.sort((a, b) => (a.date === b.date ? 0 : a.date < b.date ? 1 : -1));
+    return merged.slice(0, MAX_RECENT_TOPIC_ITEMS);
+}
+async function requestRecentTopicsForDate(config, input) {
+    const existingBlock = input.existingTopics.length > 0
+        ? input.existingTopics.map((topic) => `- ${topic.date}: ${topic.text}`).join("\n")
+        : "(none)";
+    const response = await getAiProvider()(config, {
+        model_id: input.modelId,
+        temperature: 0,
+        messages: [
+            {
+                role: "system",
+                content: [
+                    "You extract recent conversation topics for one day, to append into Agent-Sin's short-lived 'Recent 7-day topics' section inside memory.md.",
+                    "Each output topic represents a topic that was active in the target-date conversation. Older topics from previous days are already kept by the system; do not restate them unless they were genuinely revisited today.",
+                    "Capture what the user is working on, investigating, deciding, playing, tracking, or discussing — including work/project topics and notable personal, hobby, health, media, and life-context topics.",
+                    "Keep concrete project, product, game, and skill names when useful. Merge duplicates within the day. Maximum 5 new topics.",
+                    "Each topic: one concise sentence, in the same language as the source.",
+                    "Do not include secrets, tokens, raw logs, private identifiers, URL lists, or sensitive facts about other people.",
+                    "Avoid detailed private finance or family facts; if such a thread matters, keep it broad and non-identifying.",
+                    "Do not restate stable preferences unless they were an active topic today.",
+                    'Output JSON only: {"topics":[{"text":"..."}]}. If nothing qualifies, return {"topics":[]}.',
+                ].join("\n"),
+            },
+            {
+                role: "user",
+                content: [
+                    `Target date: ${input.targetDate}`,
+                    "",
+                    "<existing-recent-topics>",
+                    existingBlock,
+                    "</existing-recent-topics>",
+                    "",
+                    `<daily-conversation.md date="${input.targetDate}">`,
+                    input.dailyContent,
+                    `</daily-conversation.md>`,
+                ].join("\n").slice(0, MAX_RECENT_TOPIC_INPUT_CHARS),
+            },
+        ],
+    });
+    const texts = parseRecentTopicsResponse(response.text);
+    return texts.map((text) => ({ date: input.targetDate, text }));
+}
+function compactDailyMemoryForRecentTopics(raw) {
+    const parsed = parseDailyMemoryEntries(raw);
+    if (parsed.entries.length === 0) {
+        return clipAround(raw, MAX_RECENT_TOPIC_DAILY_CHARS);
+    }
+    const userEntries = parsed.entries
+        .filter((entry) => entry.role === "user")
+        .map((entry) => formatRecentTopicEntry(entry, MAX_RECENT_TOPIC_USER_ENTRY_CHARS))
+        .filter(Boolean);
+    const contextEntries = parsed.entries
+        .filter((entry) => entry.role === "assistant" || entry.role === "tool")
+        .map((entry) => formatRecentTopicEntry(entry, entry.role === "tool" ? MAX_RECENT_TOPIC_TOOL_ENTRY_CHARS : MAX_RECENT_TOPIC_ASSISTANT_ENTRY_CHARS))
+        .filter(Boolean);
+    const header = [
+        parsed.title,
+        "",
+        "<!-- Compacted for recent topic extraction. Direct user entries are prioritized; assistant/tool entries are included as context when budget allows. -->",
+        "",
+    ].join("\n");
+    const directSection = userEntries.length > 0
+        ? ["## Direct user entries", "", userEntries.join("\n\n")].join("\n")
+        : "## Direct user entries\n\n(no direct user entries)";
+    const contextSection = contextEntries.length > 0
+        ? ["## Assistant/tool context", "", contextEntries.join("\n\n")].join("\n")
+        : "";
+    const directOnly = `${header}${directSection}`.trimEnd();
+    if (directOnly.length >= MAX_RECENT_TOPIC_DAILY_CHARS || !contextSection) {
+        return `${clipAround(directOnly, MAX_RECENT_TOPIC_DAILY_CHARS)}\n`;
+    }
+    const remaining = MAX_RECENT_TOPIC_DAILY_CHARS - directOnly.length - 2;
+    return `${directOnly}\n\n${clipAround(contextSection, Math.max(0, remaining))}\n`;
+}
+function parseDailyMemoryEntries(raw) {
+    const lines = raw.split(/\r?\n/);
+    const title = lines.find((line) => /^#\s+\S/.test(line.trim())) || "# Daily conversation memory";
+    const entries = [];
+    let current = null;
+    for (const line of lines) {
+        const heading = line.match(/^##\s+(.+?)\s*$/);
+        if (heading) {
+            if (current) {
+                entries.push({
+                    heading: current.heading,
+                    role: dailyMemoryHeadingRole(current.heading),
+                    body: current.body.join("\n").trim(),
+                });
+            }
+            current = { heading: heading[1].trim(), body: [] };
+            continue;
+        }
+        if (current) {
+            current.body.push(line);
+        }
+    }
+    if (current) {
+        entries.push({
+            heading: current.heading,
+            role: dailyMemoryHeadingRole(current.heading),
+            body: current.body.join("\n").trim(),
+        });
+    }
+    return { title, entries };
+}
+function dailyMemoryHeadingRole(heading) {
+    const match = heading.trim().match(/\b(system|user|assistant|tool)\s*$/);
+    return match?.[1] || "";
+}
+function formatRecentTopicEntry(entry, maxBodyChars) {
+    const body = normalizeRecentTopicEntryBody(entry.role, entry.body);
+    if (!body) {
+        return "";
+    }
+    return [`### ${entry.heading}`, clipAround(body, maxBodyChars)].join("\n\n");
+}
+function normalizeRecentTopicEntryBody(role, body) {
+    const trimmed = body.trim();
+    if (!trimmed) {
+        return "";
+    }
+    if (role === "assistant") {
+        const parsed = parseJsonObject(trimmed);
+        if (parsed) {
+            return normalizeAssistantEnvelope(parsed) || scrubRecentTopicText(trimmed);
+        }
+    }
+    if (role === "tool") {
+        const fenced = trimmed.match(/```skill-result\s*([\s\S]*?)```/i);
+        const parsed = parseJsonObject(fenced?.[1]?.trim() || trimmed);
+        if (parsed) {
+            const summary = parsed.summary;
+            return scrubRecentTopicText(typeof summary === "string" ? summary : trimmed);
+        }
+    }
+    return scrubRecentTopicText(trimmed);
+}
+function normalizeAssistantEnvelope(value) {
+    const parts = [];
+    if (typeof value.reply === "string" && value.reply.trim()) {
+        parts.push(value.reply.trim());
+    }
+    const calls = Array.isArray(value.skill_calls) ? value.skill_calls : [];
+    const callTexts = calls
+        .map((call) => {
+        if (!call || typeof call !== "object")
+            return "";
+        const record = call;
+        const id = typeof record.id === "string" ? record.id : "";
+        const args = record.args && typeof record.args === "object" ? record.args : {};
+        const text = typeof args.text === "string" ? args.text : "";
+        return [id, text].filter(Boolean).join(": ");
+    })
+        .filter(Boolean);
+    if (callTexts.length > 0) {
+        parts.push(`Skill calls: ${callTexts.join("; ")}`);
+    }
+    return scrubRecentTopicText(parts.join("\n\n"));
+}
+function parseJsonObject(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function scrubRecentTopicText(text) {
+    return text
+        .replace(/\/Users\/[^\s)]+/g, "[local path]")
+        .replace(/\s+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+export function parseRecentTopicsResponse(text) {
+    const jsonText = extractJson(text);
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonText);
+    }
+    catch {
+        return [];
+    }
+    const rawItems = Array.isArray(parsed)
+        ? parsed
+        : parsed && typeof parsed === "object" && Array.isArray(parsed.topics)
+            ? parsed.topics
+            : parsed && typeof parsed === "object" && Array.isArray(parsed.items)
+                ? parsed.items
+                : [];
+    const seen = new Set();
+    const topics = [];
+    for (const item of rawItems) {
+        const textValue = topicText(item);
+        const cleaned = cleanRecentTopic(textValue);
+        const key = normalizeForDedupe(cleaned);
+        if (!cleaned || !key || seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        topics.push(cleaned);
+        if (topics.length >= MAX_RECENT_TOPIC_ITEMS) {
+            break;
+        }
+    }
+    return topics;
+}
+function topicText(item) {
+    if (typeof item === "string") {
+        return item;
+    }
+    if (item && typeof item === "object") {
+        const record = item;
+        const value = record.text || record.topic || record.summary || record.content;
+        return typeof value === "string" ? value : "";
+    }
+    return "";
+}
+function cleanRecentTopic(text) {
+    return text
+        .replace(/\s+/g, " ")
+        .replace(/^[-*・]\s*/, "")
+        .trim()
+        .slice(0, MAX_RECENT_TOPIC_CHARS);
+}
+function upsertRecentTopicsSection(original, endDate, topics) {
+    const base = removeRecentTopicsSection(original).replace(/\s+$/, "");
+    const section = formatRecentTopicsSection(endDate, topics);
+    return `${base}\n\n${section}\n`;
+}
+function formatRecentTopicsSection(endDate, topics) {
+    return [
+        l("## Recent 7-day topics", "## 直近1週間のトピック"),
+        "",
+        `<!-- ${l(`Short-lived context updated daily from the previous day's conversation memory through ${endDate}. Each line is dated; entries older than 7 days are evicted.`, `${endDate} までの前日の会話記録から日次で更新される短期トピック。各行は日付付き。7日より古い項目は自動で削除される。`)} -->`,
+        "",
+        ...topics.map((topic) => `- ${topic.date}: ${topic.text}`),
+    ].join("\n");
+}
+export function removeRecentTopicsSection(text) {
+    const lines = text.split(/\r?\n/);
+    const start = lines.findIndex((line) => recentTopicsHeading(line));
+    if (start < 0) {
+        return text;
+    }
+    let end = start + 1;
+    while (end < lines.length && !/^#{1,6}\s+\S/.test(lines[end].trim())) {
+        end += 1;
+    }
+    return [...lines.slice(0, start), ...lines.slice(end)].join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+function recentTopicsHeading(line) {
+    return /^##\s+(?:Recent 7-day topics|直近1週間のトピック)\s*$/.test(line.trim());
+}
 const MEMORY_CONSOLIDATE_INPUT_MAX = 32000;
 const MEMORY_HEADER_PATTERN = /^# memory\.md\s*$/im;
 async function consolidateMemoryFile(config, modelId, eventSource) {
     const file = profileMemoryPath(config, "memory");
     const original = await readTextIfExists(file);
-    if (!original.trim())
+    const recentTopicsSection = extractRecentTopicsSection(original);
+    const originalWithoutRecentTopics = removeRecentTopicsSection(original);
+    if (!originalWithoutRecentTopics.trim())
         return;
-    const headerBlock = extractHeaderBlock(original);
-    const body = original.slice(headerBlock.length);
+    const headerBlock = extractHeaderBlock(originalWithoutRecentTopics);
+    const body = originalWithoutRecentTopics.slice(headerBlock.length);
     if (!body.trim())
         return;
     try {
@@ -217,18 +752,20 @@ async function consolidateMemoryFile(config, modelId, eventSource) {
                 {
                     role: "system",
                     content: [
-                        "You organize Agent-Sin long-term memory. memory.md is a long-term note for understanding the user. Read the body, remove duplicates and stale items, and edit/overwrite existing items with newer information. Do not let it grow by appending only.",
+                        "You organize Agent-Sin long-term memory. memory.md is a long-term note for understanding the user across many future conversations. Read the body, then actively reshape it: remove duplicates and stale items, edit/overwrite existing items with newer information, and reclassify content under better headings when the current structure no longer fits.",
+                        "Treat this as a periodic inventory. You are encouraged to add new headings, rename headings, merge or split headings, move bullets across sections, and delete obsolete or low-signal lines. Do not let memory.md grow by pure appending, and do not freeze the existing structure just because it exists.",
                         "Output rules:",
                         "- Return only the Markdown body. No preface, afterword, or code fences.",
                         "- Write content in the same language as the original memory.md body.",
-                        "- Preserve the existing heading structure when possible and normalize content under headings to one fact per bullet line starting with '-'. Do not create date headers or 'Auto promotion: ...' / '自動昇格: ...' headings.",
+                        "- Normalize content under headings to one fact per bullet line starting with '-'. Do not create date headers or 'Auto promotion: ...' / '自動昇格: ...' headings.",
                         "- Merge items with the same meaning. If new information updates old information, discard the old version and rewrite to the latest state.",
-                        "- Always keep observations directly tied to understanding the user: role, preferences, values, communication tendencies, media preferences, and interests.",
-                        "- Remove operating rules, schedules, skill behavior settings, specific sender names, filters, recent task work, progress, and casual chat.",
-                        "- Do not keep sensitive finance/family information or information that identifies other people.",
+                        "- Prioritize keeping anything useful for understanding the user across future conversations: role, expertise, preferences, values, communication tendencies, decision habits, lifestyle patterns, broad health or self-improvement concerns, media preferences, recurring interests, stable dislikes, and long-running themes worth remembering even when they no longer come up daily.",
+                        "- Overlap with the short-lived 'Recent 7-day topics' / '直近1週間のトピック' section is acceptable when the topic is also a durable long-term interest. The recent-topics section is managed separately, so focus this output on the long-term body only.",
+                        "- Remove operating rules, schedules, skill behavior settings, specific sender names, filters, raw recent task work, transient progress, and casual chat that has no long-term signal.",
+                        "- Do not keep detailed or sensitive health/finance/family information or information that identifies other people. Keep only broad, non-identifying concerns or habits when useful.",
                         "- Do not invent content. Do not add facts not present in the source.",
                         "- Each line must be a concise generic sentence or fact. Do not include dates or 'today I...' phrasing.",
-                        "- Keep the whole result to about 25 lines at most. Reduce further when possible.",
+                        "- Aim for roughly 40 lines, and up to about 60 lines when there is genuinely durable signal worth preserving. Cut aggressively below this when items are weak or duplicative.",
                         "Even if the target is empty or does not need much cleanup, return the minimal bullet list that preserves the current state.",
                     ].join("\n"),
                 },
@@ -242,10 +779,9 @@ async function consolidateMemoryFile(config, modelId, eventSource) {
         if (!cleaned)
             return;
         const next = `${headerBlock.replace(/\s+$/, "")}\n\n${cleaned}\n`;
-        if (normalizeForCompare(next) === normalizeForCompare(original))
+        if (normalizeForCompare(next) === normalizeForCompare(originalWithoutRecentTopics))
             return;
-        await writeFile(`${file}.bak`, original, "utf8");
-        await writeFile(file, next, "utf8");
+        await writeFile(file, appendPreservedRecentTopicsSection(next, recentTopicsSection), "utf8");
         await appendEventLog(config, {
             level: "info",
             source: eventSource,
@@ -264,6 +800,25 @@ async function consolidateMemoryFile(config, modelId, eventSource) {
         });
     }
 }
+function extractRecentTopicsSection(text) {
+    const lines = text.split(/\r?\n/);
+    const start = lines.findIndex((line) => recentTopicsHeading(line));
+    if (start < 0) {
+        return "";
+    }
+    let end = start + 1;
+    while (end < lines.length && !/^#{1,6}\s+\S/.test(lines[end].trim())) {
+        end += 1;
+    }
+    return lines.slice(start, end).join("\n").trim();
+}
+function appendPreservedRecentTopicsSection(body, recentTopicsSection) {
+    const recent = recentTopicsSection.trim();
+    if (!recent) {
+        return body;
+    }
+    return `${body.replace(/\s+$/, "")}\n\n${recent}\n`;
+}
 function extractHeaderBlock(raw) {
     const match = MEMORY_HEADER_PATTERN.exec(raw);
     if (!match)
@@ -291,7 +846,7 @@ function sanitizeConsolidatedBody(text) {
         .split(/\r?\n/)
         .map((line) => line.trimEnd())
         .filter((line) => line.length > 0)
-        .map((line) => (line.startsWith("- ") || line.startsWith("# ") ? line : line.replace(/^[-*・]?\s*/, "- ")));
+        .map((line) => (line.startsWith("- ") || /^#{1,6}\s+\S/.test(line) ? line : line.replace(/^[-*・]?\s*/, "- ")));
     return lines.join("\n").trim();
 }
 function isStructuredModelPayload(text) {
@@ -381,6 +936,15 @@ function localDateString(date) {
     const dd = String(date.getDate()).padStart(2, "0");
     return `${yyyy}-${MM}-${dd}`;
 }
+function dateFromLocalDateString(value) {
+    const [yyyy, MM, dd] = value.split("-").map((part) => Number.parseInt(part, 10));
+    return new Date(yyyy, MM - 1, dd);
+}
+function addDays(date, days) {
+    const next = new Date(date);
+    next.setDate(next.getDate() + days);
+    return next;
+}
 function dailyMemoryFileForDate(config, date) {
     const [yyyy, MM, dd] = date.split("-").map((part) => Number.parseInt(part, 10));
     return dailyConversationMemoryFile(config, new Date(yyyy, MM - 1, dd));
@@ -420,3 +984,17 @@ function clip(text, max) {
     }
     return `${text.slice(0, max)}\n\n... clipped ...`;
 }
+function clipAround(text, max) {
+    if (max <= 0) {
+        return "";
+    }
+    if (text.length <= max) {
+        return text;
+    }
+    if (max < 40) {
+        return text.slice(0, max);
+    }
+    const marker = "\n\n... clipped middle ...\n\n";
+    const side = Math.floor((max - marker.length) / 2);
+    return `${text.slice(0, side)}${marker}${text.slice(text.length - side)}`;
+}