companionbot 0.5.0 → 0.6.0

package/dist/agents/index.js

@@ -1,4 +1,4 @@
 /**
  * Sub-agent 시스템 - 복잡한 작업을 독립적인 agent에게 위임
  */
-export { setAgentBot, spawnAgent, listAgents, cancelAgent, getAgent, abortAllAgents, stopCleanup } from "./manager.js";
+export { setAgentBot, spawnAgent, listAgents, cancelAgent, getAgent } from "./manager.js";

package/dist/agents/manager.js

@@ -198,14 +198,6 @@ export function cleanupOldAgents() {
         // running 상태도 1시간 지나면 정리 (stuck agent 방지)
         if (agent.status === "running" && agent.createdAt.getTime() < oneHourAgo) {
             console.log(`[Agent ${id}] Cleaning up stuck agent (running > 1h)`);
-            // 실행 중인 API 호출 취소
-            const controller = abortControllers.get(id);
-            if (controller) {
-                controller.abort();
-                abortControllers.delete(id);
-            }
-            agent.status = "cancelled";
-            agent.completedAt = new Date();
             agents.delete(id);
         }
     }
@@ -231,27 +223,5 @@ export function stopCleanup() {
         console.log("[AgentManager] Cleanup interval stopped");
     }
 }
-/**
- * 모든 진행 중인 agent abort 및 정리 (shutdown 시 사용)
- */
-export function abortAllAgents() {
-    console.log("[AgentManager] Aborting all running agents...");
-    // 모든 AbortController abort
-    for (const [id, controller] of abortControllers) {
-        console.log(`[Agent ${id}] Aborting`);
-        controller.abort();
-    }
-    abortControllers.clear();
-    // 모든 running agent 상태 업데이트
-    for (const [id, agent] of agents) {
-        if (agent.status === "running") {
-            agent.status = "cancelled";
-            agent.completedAt = new Date();
-        }
-    }
-    // cleanup interval 중지
-    stopCleanup();
-    console.log("[AgentManager] All agents aborted");
-}
 // 자동 시작
 startCleanup();

package/dist/ai/claude.js

@@ -7,29 +7,59 @@ function getClient() {
     }
     return anthropic;
 }
+// 모델별 max_tokens 및 thinking budget 설정
+// 참고: Claude API에서 thinking + output이 모델 한도 초과하면 안 됨
 export const MODELS = {
-    sonnet: { id: "claude-sonnet-4-20250514", name: "Claude Sonnet 4" },
-    opus: { id: "claude-opus-4-20250514", name: "Claude Opus 4" },
-    haiku: { id: "claude-haiku-3-5-20241022", name: "Claude Haiku 3.5" },
+    haiku: {
+        id: "claude-haiku-3-5-20241022",
+        name: "Claude Haiku 3.5",
+        maxTokens: 4096, // 빠른 응답
+        thinkingBudget: 0, // Haiku는 thinking 미지원
+    },
+    sonnet: {
+        id: "claude-sonnet-4-20250514",
+        name: "Claude Sonnet 4",
+        maxTokens: 8192, // 일반 작업
+        thinkingBudget: 10000, // 적당한 thinking
+    },
+    opus: {
+        id: "claude-opus-4-20250514",
+        name: "Claude Opus 4",
+        maxTokens: 16384, // 복잡한 작업
+        thinkingBudget: 32000, // 깊은 thinking
+    },
 };
-export async function chat(messages, systemPrompt, modelId = "sonnet", options) {
+export async function chat(messages, systemPrompt, modelId = "sonnet") {
     const client = getClient();
-    const model = MODELS[modelId].id;
-    const signal = options?.signal;
+    const modelConfig = MODELS[modelId];
     // 메시지를 API 형식으로 변환
     const apiMessages = messages.map((m) => ({
         role: m.role,
         content: m.content,
     }));
-    let response;
-    try {
-        response = await client.messages.create({
-            model,
-            max_tokens: 4096,
-            system: systemPrompt,
+    // API 요청 파라미터 빌드 (도구 루프에서도 동일하게 사용)
+    const buildRequestParams = () => {
+        const params = {
+            model: modelConfig.id,
+            max_tokens: modelConfig.maxTokens,
             messages: apiMessages,
             tools: tools,
-        }, { signal });
+        };
+        if (systemPrompt) {
+            params.system = systemPrompt;
+        }
+        // thinking 활성화 (budget > 0인 경우)
+        if (modelConfig.thinkingBudget > 0) {
+            params.thinking = {
+                type: "enabled",
+                budget_tokens: modelConfig.thinkingBudget,
+            };
+        }
+        return params;
+    };
+    let response;
+    try {
+        response = await client.messages.create(buildRequestParams());
     }
     catch (error) {
         if (error instanceof Anthropic.APIError) {
@@ -72,15 +102,9 @@ export async function chat(messages, systemPrompt, modelId = "sonnet", options)
             role: "user",
             content: toolResults,
         });
-        // 다음 응답 요청
+        // 다음 응답 요청 (도구 루프에서도 thinking 유지)
         try {
-            response = await client.messages.create({
-                model,
-                max_tokens: 4096,
-                system: systemPrompt,
-                messages: apiMessages,
-                tools: tools,
-            }, { signal });
+            response = await client.messages.create(buildRequestParams());
         }
         catch (error) {
             if (error instanceof Anthropic.APIError) {
@@ -103,3 +127,90 @@ export async function chat(messages, systemPrompt, modelId = "sonnet", options)
     const textBlock = response.content.find((block) => block.type === "text");
     return textBlock?.text ?? "응답을 생성하지 못했어. 다시 시도해줄래?";
 }
+/**
+ * 스마트 채팅 - 가능하면 스트리밍, 도구 필요하면 일반 호출
+ *
+ * 전략:
+ * - 먼저 스트리밍으로 시도
+ * - 도구 호출이 감지되면 (stop_reason === "tool_use") 기존 chat()으로 폴백
+ * - 스트리밍은 최종 텍스트 응답에만 사용
+ */
+export async function chatSmart(messages, systemPrompt, modelId, onChunk) {
+    // 스트리밍 콜백이 없으면 그냥 일반 chat 사용
+    if (!onChunk) {
+        const text = await chat(messages, systemPrompt, modelId);
+        return { text, usedTools: false };
+    }
+    const client = getClient();
+    const modelConfig = MODELS[modelId];
+    // 메시지를 API 형식으로 변환
+    const apiMessages = messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+    }));
+    // 스트리밍 요청 파라미터
+    const params = {
+        model: modelConfig.id,
+        max_tokens: modelConfig.maxTokens,
+        messages: apiMessages,
+        tools: tools,
+        stream: true,
+    };
+    if (systemPrompt) {
+        params.system = systemPrompt;
+    }
+    // Thinking은 스트리밍에서 복잡해지므로 일단 비활성화
+    // (도구 호출 폴백 시 chat()에서 thinking 사용됨)
+    let accumulated = "";
+    let stopReason = null;
+    try {
+        const stream = client.messages.stream(params);
+        // 스트리밍 이벤트 처리
+        stream.on("text", async (text) => {
+            accumulated += text;
+            try {
+                await onChunk(text, accumulated);
+            }
+            catch (err) {
+                // editMessageText 실패 등은 무시하고 계속
+                console.warn("[Stream] Chunk callback error (ignored):", err);
+            }
+        });
+        // 스트림 완료 대기
+        const finalMessage = await stream.finalMessage();
+        stopReason = finalMessage.stop_reason;
+        // 도구 호출이 필요한 경우 - 일반 chat으로 폴백
+        if (stopReason === "tool_use") {
+            console.log("[Stream] Tool use detected, falling back to chat()");
+            const text = await chat(messages, systemPrompt, modelId);
+            return { text, usedTools: true };
+        }
+        // 성공적으로 스트리밍 완료
+        return { text: accumulated, usedTools: false };
+    }
+    catch (error) {
+        // 스트리밍 에러 핸들링
+        if (error instanceof Anthropic.APIError) {
+            if (error.status === 429) {
+                throw new Error("API 요청이 너무 많아. 잠시 후 다시 시도해줘.");
+            }
+            if (error.status >= 500) {
+                throw new Error("AI 서버에 문제가 생겼어. 잠시 후 다시 시도해줘.");
+            }
+        }
+        // 연결 끊김 등 스트리밍 에러 - 이미 받은 내용이 있으면 반환 시도
+        if (accumulated.length > 50) {
+            console.warn("[Stream] Connection error, returning partial response");
+            return { text: accumulated + "\n\n(연결이 끊겨서 응답이 잘렸을 수 있어)", usedTools: false };
+        }
+        // 응답이 거의 없으면 일반 chat으로 재시도
+        console.warn("[Stream] Connection error, retrying with chat()");
+        try {
+            const text = await chat(messages, systemPrompt, modelId);
+            return { text, usedTools: false };
+        }
+        catch (retryError) {
+            throw retryError;
+        }
+    }
+}

package/dist/cron/index.js

@@ -8,7 +8,7 @@ export { isValidCronExpression, parseCronExpression, getNextCronRun, getNextRun,
 // Storage functions
 export { loadJobs, saveJobs, addJob, removeJob, updateJob, getDueJobs, markJobExecuted, getJobsByChat, getJob, calculateNextRun, } from "./store.js";
 // Scheduler functions
-export { CronScheduler, executeJob, setCronBot, startCronScheduler, stopCronScheduler, isCronSchedulerRunning, initCronSystem, restoreCronJobs, createCronJob, deleteCronJob, toggleCronJob, getCronJobs, getAllCronJobs, getActiveJobCount, } from "./scheduler.js";
+export { CronScheduler, executeJob, setCronBot, startCronScheduler, stopCronScheduler, isCronSchedulerRunning, initCronSystem, restoreCronJobs, createCronJob, deleteCronJob, toggleCronJob, getCronJobs, getAllCronJobs, getActiveJobCount, ensureDefaultCronJobs, } from "./scheduler.js";
 // Command handlers (for tools)
 export { addCronJob, removeCronJob, setCronJobEnabled, listCronJobs, getCronStatus, } from "./commands.js";
 // Aliases for backward compatibility

package/dist/cron/parser.js

@@ -130,163 +130,30 @@ export function parseCronExpression(expr) {
     };
 }
 /**
- * Get time components in a specific timezone using Intl API
- */
-function getTimeInTimezone(date, timezone) {
-    try {
-        const formatter = new Intl.DateTimeFormat("en-US", {
-            timeZone: timezone,
-            year: "numeric",
-            month: "2-digit",
-            day: "2-digit",
-            hour: "2-digit",
-            minute: "2-digit",
-            weekday: "short",
-            hour12: false,
-        });
-        const parts = formatter.formatToParts(date);
-        const getValue = (type) => parts.find((p) => p.type === type)?.value ?? "0";
-        const dayOfWeekMap = {
-            Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6,
-        };
-        return {
-            year: parseInt(getValue("year"), 10),
-            month: parseInt(getValue("month"), 10),
-            day: parseInt(getValue("day"), 10),
-            hour: parseInt(getValue("hour"), 10),
-            minute: parseInt(getValue("minute"), 10),
-            dayOfWeek: dayOfWeekMap[getValue("weekday")] ?? 0,
-        };
-    }
-    catch {
-        // Fallback to local time if timezone is invalid
-        return {
-            year: date.getFullYear(),
-            month: date.getMonth() + 1,
-            day: date.getDate(),
-            hour: date.getHours(),
-            minute: date.getMinutes(),
-            dayOfWeek: date.getDay(),
-        };
-    }
-}
-/**
- * Create a Date object for a specific time in a timezone
- */
-function createDateInTimezone(year, month, day, hour, minute, timezone) {
-    try {
-        const dateStr = `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}T${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}:00`;
-        const formatter = new Intl.DateTimeFormat("en-US", {
-            timeZone: timezone,
-            year: "numeric",
-            month: "2-digit",
-            day: "2-digit",
-            hour: "2-digit",
-            minute: "2-digit",
-            hour12: false,
-        });
-        // Binary search for the correct UTC time
-        let guess = new Date(dateStr);
-        for (let i = 0; i < 3; i++) {
-            const parts = formatter.formatToParts(guess);
-            const getValue = (type) => parseInt(parts.find((p) => p.type === type)?.value ?? "0", 10);
-            const guessHour = getValue("hour");
-            const guessMinute = getValue("minute");
-            const guessDay = getValue("day");
-            let diffMinutes = (hour - guessHour) * 60 + (minute - guessMinute);
-            if (day !== guessDay) {
-                if (day > guessDay || (day === 1 && guessDay > 20)) {
-                    diffMinutes += 24 * 60;
-                }
-                else {
-                    diffMinutes -= 24 * 60;
-                }
-            }
-            if (diffMinutes === 0)
-                break;
-            guess = new Date(guess.getTime() + diffMinutes * 60 * 1000);
-        }
-        return guess;
-    }
-    catch {
-        return new Date(year, month - 1, day, hour, minute, 0, 0);
-    }
-}
-/**
- * Get number of days in a month
- */
-function getDaysInMonth(year, month) {
-    return new Date(year, month, 0).getDate();
-}
-/**
- * Calculate the next run time for a cron expression with timezone support
+ * Calculate the next run time for a cron expression
  */
 export function getNextCronRun(expression, fromDate = new Date(), timezone) {
     const parsed = parseCronExpression(expression);
-    const now = fromDate;
-    const tz = timezone || Intl.DateTimeFormat().resolvedOptions().timeZone;
-    // Get current time in target timezone
-    const current = getTimeInTimezone(now, tz);
-    // Search for next valid time (up to 366 days ahead)
-    const searchDate = { ...current };
-    const maxIterations = 366 * 24 * 60;
+    const from = new Date(fromDate);
+    // Start from the next minute
+    from.setSeconds(0);
+    from.setMilliseconds(0);
+    from.setMinutes(from.getMinutes() + 1);
+    // Search for the next matching time (max 2 years ahead)
+    const maxIterations = 365 * 24 * 60 * 2; // 2 years in minutes
     for (let i = 0; i < maxIterations; i++) {
-        // Advance by one minute each iteration
-        if (i > 0) {
-            searchDate.minute++;
-            if (searchDate.minute > 59) {
-                searchDate.minute = 0;
-                searchDate.hour++;
-                if (searchDate.hour > 23) {
-                    searchDate.hour = 0;
-                    searchDate.day++;
-                    searchDate.dayOfWeek = (searchDate.dayOfWeek + 1) % 7;
-                    const daysInMonth = getDaysInMonth(searchDate.year, searchDate.month);
-                    if (searchDate.day > daysInMonth) {
-                        searchDate.day = 1;
-                        searchDate.month++;
-                        if (searchDate.month > 12) {
-                            searchDate.month = 1;
-                            searchDate.year++;
-                        }
-                    }
-                }
-            }
-        }
-        // Check if this time matches all constraints
-        if (!parsed.month.values.includes(searchDate.month))
-            continue;
-        // For dayOfMonth and dayOfWeek: if both are restricted, match either (OR logic)
-        // If only one is restricted, use that one
-        const domRestricted = parsed.dayOfMonth.type !== "wildcard";
-        const dowRestricted = parsed.dayOfWeek.type !== "wildcard";
-        if (domRestricted && dowRestricted) {
-            // Both restricted: match either
-            if (!parsed.dayOfMonth.values.includes(searchDate.day) &&
-                !parsed.dayOfWeek.values.includes(searchDate.dayOfWeek)) {
-                continue;
-            }
-        }
-        else if (domRestricted) {
-            if (!parsed.dayOfMonth.values.includes(searchDate.day))
-                continue;
-        }
-        else if (dowRestricted) {
-            if (!parsed.dayOfWeek.values.includes(searchDate.dayOfWeek))
-                continue;
-        }
-        if (!parsed.hour.values.includes(searchDate.hour))
-            continue;
-        if (!parsed.minute.values.includes(searchDate.minute))
-            continue;
-        // Skip if this is the current minute (must be in the future)
-        if (i === 0)
-            continue;
-        // Create the date in the target timezone
-        const nextRun = createDateInTimezone(searchDate.year, searchDate.month, searchDate.day, searchDate.hour, searchDate.minute, tz);
-        // Verify it's in the future
-        if (nextRun > now) {
-            return nextRun;
+        const candidate = new Date(from.getTime() + i * 60000);
+        const minute = candidate.getMinutes();
+        const hour = candidate.getHours();
+        const dayOfMonth = candidate.getDate();
+        const month = candidate.getMonth() + 1;
+        const dayOfWeek = candidate.getDay();
+        if (parsed.minute.values.includes(minute) &&
+            parsed.hour.values.includes(hour) &&
+            parsed.month.values.includes(month) &&
+            (parsed.dayOfMonth.values.includes(dayOfMonth) ||
+                parsed.dayOfWeek.values.includes(dayOfWeek))) {
+            return candidate;
         }
     }
     throw new Error(`Could not find next run time for: ${expression}`);

package/dist/cron/scheduler.js

@@ -7,7 +7,6 @@
 import { getDueJobs, markJobExecuted, loadJobs, addJob, removeJob, updateJob, getJobsByChat } from "./store.js";
 import { chat } from "../ai/claude.js";
 import { buildSystemPrompt } from "../telegram/utils/prompt.js";
-import { runWithChatId } from "../session/state.js";
 // Scheduler state
 let schedulerInterval = null;
 let botInstance = null;
@@ -146,8 +145,7 @@ async function executeSystemEvent(job, payload, bot) {
  */
 async function executeAgentTurn(job, payload, bot) {
     const { message: inputMessage, context } = payload;
-    // Wrap in runWithChatId so tools can access chatId via getCurrentChatId()
-    const response = await runWithChatId(job.chatId, async () => {
+    try {
         // Build a fresh conversation for this job (separate from main chat)
         const messages = [
             {
@@ -167,10 +165,8 @@ async function executeAgentTurn(job, payload, bot) {
 - Run Count: ${(job.runCount || 0) + 1}
 - This is a scheduled task, not a direct user message.`;
         // Call Claude API
-        return await chat(messages, systemPrompt, "sonnet");
-    });
-    // Send the response to the chat
-    try {
+        const response = await chat(messages, systemPrompt, "sonnet");
+        // Send the response to the chat
         if (response && response.trim()) {
             // Split long messages (Telegram limit is 4096 characters)
             const maxLength = 4000;
@@ -328,3 +324,34 @@ export function getActiveJobCount() {
     // For actual count, use getAllCronJobs and filter
     return 0; // Placeholder - will be updated by scheduler
 }
+// ============================================================
+// Default Cron Jobs
+// ============================================================
+const DEFAULT_CRON_JOBS = [
+    {
+        name: "daily_memory_save",
+        cronExpr: "0 12 * * *", // 매일 12시
+        command: "오늘 하루 동안 있었던 중요한 일들을 정리해서 MEMORY.md에 저장해줘. 새로운 정보, 대화 내용, 배운 것들 위주로.",
+        timezone: "Asia/Seoul",
+    },
+];
+/**
+ * Ensure default cron jobs exist for a chat
+ * Call this after onboarding or on /start
+ */
+export async function ensureDefaultCronJobs(chatId) {
+    const existingJobs = await getJobsByChat(chatId);
+    for (const defaultJob of DEFAULT_CRON_JOBS) {
+        const exists = existingJobs.some(job => job.name === defaultJob.name);
+        if (!exists) {
+            await createCronJob({
+                chatId,
+                name: defaultJob.name,
+                cronExpr: defaultJob.cronExpr,
+                command: defaultJob.command,
+                timezone: defaultJob.timezone,
+            });
+            console.log(`[Cron] Added default job: ${defaultJob.name} for chat ${chatId}`);
+        }
+    }
+}

package/dist/heartbeat/index.js

@@ -4,7 +4,6 @@ import { getWorkspacePath } from "../workspace/index.js";
 import { chat } from "../ai/claude.js";
 import { isCalendarConfigured, getTodayEvents, formatEvent } from "../calendar/index.js";
 import { getSecret } from "../config/secrets.js";
-import { runWithChatId } from "../session/state.js";
 // 활성 타이머
 const activeTimers = new Map();
 // 메모리 캐시: 타임스탬프는 메모리에만 유지하여 파일 쓰기 최소화
@@ -121,10 +120,7 @@ ${context}
     ];
     let messageSent = false;
     try {
-        // Wrap in runWithChatId so tools can access chatId via getCurrentChatId()
-        const response = await runWithChatId(config.chatId, async () => {
-            return await chat(messages, systemPrompt, "haiku");
-        });
+        const response = await chat(messages, systemPrompt, "haiku");
         if (!response.trim().includes("HEARTBEAT_OK")) {
             await botInstance.api.sendMessage(config.chatId, response);
             console.log(`[Heartbeat] Sent message to ${config.chatId}`);

package/dist/memory/embeddings.js

@@ -0,0 +1,94 @@
+/**
+ * 로컬 임베딩 생성 모듈
+ * @xenova/transformers를 사용하여 텍스트 임베딩을 생성합니다.
+ */
+import { pipeline } from "@xenova/transformers";
+// 싱글톤 파이프라인
+let embeddingPipeline = null;
+// 모델 로딩 중인지 추적
+let isLoading = false;
+let loadingPromise = null;
+/**
+ * 임베딩 파이프라인을 초기화합니다.
+ * 작고 빠른 모델 사용 (384 차원)
+ */
+async function getEmbeddingPipeline() {
+    if (embeddingPipeline) {
+        return embeddingPipeline;
+    }
+    // 이미 로딩 중이면 기다림
+    if (isLoading && loadingPromise) {
+        return loadingPromise;
+    }
+    isLoading = true;
+    loadingPromise = pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2" // 384차원, 빠르고 가벼움
+    );
+    try {
+        embeddingPipeline = await loadingPromise;
+        return embeddingPipeline;
+    }
+    finally {
+        isLoading = false;
+    }
+}
+/**
+ * 텍스트를 임베딩 벡터로 변환합니다.
+ * @param text 변환할 텍스트
+ * @returns 384차원 임베딩 벡터
+ */
+export async function embed(text) {
+    const pipe = await getEmbeddingPipeline();
+    // 텍스트 정규화
+    const cleanText = text.trim().slice(0, 512); // 최대 512자
+    if (!cleanText) {
+        return new Array(384).fill(0);
+    }
+    const result = await pipe(cleanText, {
+        pooling: "mean",
+        normalize: true,
+    });
+    // Tensor를 배열로 변환
+    return Array.from(result.data);
+}
+/**
+ * 여러 텍스트를 배치로 임베딩합니다.
+ * @param texts 변환할 텍스트 배열
+ * @returns 임베딩 벡터 배열
+ */
+export async function embedBatch(texts) {
+    const results = [];
+    for (const text of texts) {
+        results.push(await embed(text));
+    }
+    return results;
+}
+/**
+ * 두 벡터 간의 코사인 유사도를 계산합니다.
+ *
+ * 최적화: embed()에서 normalize: true로 정규화된 벡터를 반환하므로,
+ * 정규화된 벡터의 경우 코사인 유사도 = 내적 (norm이 1이므로)
+ * normalized 파라미터가 true면 내적만 계산하여 성능 향상.
+ */
+export function cosineSimilarity(a, b, normalized = true) {
+    if (a.length !== b.length)
+        return 0;
+    let dotProduct = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+    }
+    // 정규화된 벡터면 내적 = 코사인 유사도
+    if (normalized) {
+        return dotProduct;
+    }
+    // 정규화되지 않은 벡터면 norm 계산 필요
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+    if (denominator === 0)
+        return 0;
+    return dotProduct / denominator;
+}

package/dist/memory/index.js

@@ -0,0 +1,4 @@
+// Memory module exports
+export { embed, embedBatch, cosineSimilarity } from './embeddings.js';
+export { search, invalidateCache } from './vectorStore.js';
+export { indexFile, indexMainMemory, indexDailyMemories, reindexAll } from './indexer.js';

package/dist/memory/indexer.js

@@ -0,0 +1,39 @@
+/**
+ * 메모리 인덱서 모듈
+ * 현재 구현은 vectorStore가 on-demand로 로드하므로 캐시 무효화만 수행
+ */
+import { invalidateCache } from './vectorStore.js';
+// 단일 파일 인덱싱 (캐시 무효화)
+export async function indexFile(_filePath, _source) {
+    // vectorStore가 on-demand로 로드하므로 캐시만 무효화
+    invalidateCache();
+    return 1;
+}
+// MEMORY.md 인덱싱
+export async function indexMainMemory() {
+    invalidateCache();
+    return 1;
+}
+// 일일 메모리 파일들 인덱싱
+export async function indexDailyMemories(_days = 30) {
+    invalidateCache();
+    return 1;
+}
+// 전체 리인덱싱 (캐시 무효화 후 미리 로드)
+export async function reindexAll() {
+    console.log('[Indexer] Invalidating cache for reindex...');
+    invalidateCache();
+    // 캐시 무효화 후 즉시 로드하여 청크 수 반환
+    // search를 임시로 호출하여 로드 트리거 (빈 쿼리로)
+    const { loadAllMemoryChunks } = await import('./vectorStore.js');
+    const chunks = await loadAllMemoryChunks();
+    // 소스별 집계
+    const sourceCounts = new Map();
+    for (const chunk of chunks) {
+        sourceCounts.set(chunk.source, (sourceCounts.get(chunk.source) || 0) + 1);
+    }
+    return {
+        total: chunks.length,
+        sources: Array.from(sourceCounts.keys())
+    };
+}