stella-timeline-plugin 2.0.0

package/dist/src/runtime/openclaw_timeline_runtime.js

@@ -0,0 +1,655 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeOpenClawTimelineResolveToolFactory = makeOpenClawTimelineResolveToolFactory;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const conversation_context_1 = require("./conversation_context");
+const timeline_resolve_1 = require("../tools/timeline_resolve");
+function readString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function readBoolean(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
+function readInteger(value, fallback) {
+    return Number.isInteger(value) && Number(value) > 0 ? Number(value) : fallback;
+}
+function resolvePluginRuntimeConfig(pluginConfig) {
+    return {
+        enableTrace: readBoolean(pluginConfig?.enableTrace, true),
+        traceLogPath: readString(pluginConfig?.traceLogPath),
+        canonicalMemoryRoot: readString(pluginConfig?.canonicalMemoryRoot) || 'memory',
+        reasonerTimeoutMs: readInteger(pluginConfig?.reasonerTimeoutMs, 45000),
+        reasonerSessionPrefix: readString(pluginConfig?.reasonerSessionPrefix) || 'timeline-reasoner',
+        reasonerMessageLimit: readInteger(pluginConfig?.reasonerMessageLimit, 24),
+        sessionHistoryLimit: readInteger(pluginConfig?.sessionHistoryLimit, 12),
+        memorySearchMaxResults: readInteger(pluginConfig?.memorySearchMaxResults, 6),
+        conversationStickinessWindowMinutes: readInteger(pluginConfig?.conversationStickinessWindowMinutes, 10),
+    };
+}
+function wrapToolPayload(payload) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+        details: payload,
+    };
+}
+function resolveWorkspaceDir(pluginApi, toolContext) {
+    if (toolContext.workspaceDir)
+        return toolContext.workspaceDir;
+    if (pluginApi.workspaceDir)
+        return pluginApi.workspaceDir;
+    if (typeof pluginApi.resolvePath === 'function')
+        return pluginApi.resolvePath('.');
+    return process.cwd();
+}
+function resolveConfiguredPath(workspaceDir, configuredPath, fallbackRelativePath) {
+    const raw = configuredPath || fallbackRelativePath;
+    return path.isAbsolute(raw) ? path.normalize(raw) : path.normalize(path.join(workspaceDir, raw));
+}
+function formatOffsetMinutes(offsetMinutes) {
+    const sign = offsetMinutes >= 0 ? '+' : '-';
+    const abs = Math.abs(offsetMinutes);
+    const hours = String(Math.floor(abs / 60)).padStart(2, '0');
+    const minutes = String(abs % 60).padStart(2, '0');
+    return `${sign}${hours}:${minutes}`;
+}
+function formatCurrentTimestamp(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const hour = String(date.getHours()).padStart(2, '0');
+    const minute = String(date.getMinutes()).padStart(2, '0');
+    const second = String(date.getSeconds()).padStart(2, '0');
+    const offset = formatOffsetMinutes(-date.getTimezoneOffset());
+    return `${year}-${month}-${day}T${hour}:${minute}:${second}${offset}`;
+}
+function readWorkspaceTextFile(filePath) {
+    try {
+        return fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function buildMemorySearchQuery(input) {
+    const explicit = readString(input.query);
+    if (explicit)
+        return explicit;
+    return null;
+}
+function stringifySearchResult(entry) {
+    if (!entry || typeof entry !== 'object') {
+        return typeof entry === 'string' ? entry : JSON.stringify(entry);
+    }
+    const record = entry;
+    if (typeof record.snippet === 'string' && record.snippet.trim())
+        return record.snippet.trim();
+    return JSON.stringify(entry);
+}
+function extractMessageText(value) {
+    if (typeof value === 'string')
+        return value.trim();
+    if (!value || typeof value !== 'object')
+        return '';
+    const record = value;
+    const directKeys = ['bodyText', 'body', 'text', 'contentText'];
+    for (const key of directKeys) {
+        if (typeof record[key] === 'string' && String(record[key]).trim()) {
+            return String(record[key]).trim();
+        }
+    }
+    if (Array.isArray(record.content)) {
+        const joined = record.content
+            .map((part) => extractMessageText(part))
+            .filter(Boolean)
+            .join('\n');
+        if (joined)
+            return joined;
+    }
+    if (record.content && typeof record.content === 'object') {
+        const nestedContent = extractMessageText(record.content);
+        if (nestedContent)
+            return nestedContent;
+    }
+    if (record.message && typeof record.message === 'object') {
+        const nestedMessage = extractMessageText(record.message);
+        if (nestedMessage)
+            return nestedMessage;
+    }
+    if (typeof record.type === 'string' && record.type === 'text' && typeof record.text === 'string') {
+        return record.text.trim();
+    }
+    return '';
+}
+function extractMessageRole(value) {
+    if (!value || typeof value !== 'object')
+        return 'unknown';
+    const directRole = value.role;
+    if (typeof directRole === 'string' && directRole.trim()) {
+        return directRole.trim();
+    }
+    const nestedMessage = value.message;
+    if (nestedMessage && typeof nestedMessage === 'object') {
+        const nestedRole = nestedMessage.role;
+        if (typeof nestedRole === 'string' && nestedRole.trim()) {
+            return nestedRole.trim();
+        }
+    }
+    return 'unknown';
+}
+function normalizeSessionHistory(messages, limit) {
+    return messages
+        .map((message) => {
+        const role = extractMessageRole(message);
+        const text = extractMessageText(message);
+        return text ? `${role}: ${text}` : '';
+    })
+        .filter(Boolean)
+        .slice(-limit);
+}
+function extractLatestAssistantText(messages) {
+    const reversed = [...messages].reverse();
+    for (const message of reversed) {
+        const role = typeof message?.role === 'string'
+            ? String(message.role).trim()
+            : '';
+        const text = extractMessageText(message);
+        if (role === 'assistant' && text)
+            return text;
+    }
+    for (const message of reversed) {
+        const text = extractMessageText(message);
+        if (text)
+            return text;
+    }
+    return '';
+}
+function collectBalancedJsonObjects(text) {
+    const objects = [];
+    let depth = 0;
+    let start = -1;
+    let inString = false;
+    let escaping = false;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (escaping) {
+            escaping = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaping = true;
+            continue;
+        }
+        if (char === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (inString) {
+            continue;
+        }
+        if (char === '{') {
+            if (depth === 0) {
+                start = index;
+            }
+            depth += 1;
+            continue;
+        }
+        if (char === '}') {
+            if (depth === 0) {
+                continue;
+            }
+            depth -= 1;
+            if (depth === 0 && start !== -1) {
+                objects.push(text.slice(start, index + 1));
+                start = -1;
+            }
+        }
+    }
+    return objects;
+}
+function tryExtractJsonObject(text, expectedRequestId) {
+    const fencedMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const candidate = fencedMatch?.[1]?.trim() || text.trim();
+    const objects = collectBalancedJsonObjects(candidate);
+    if (objects.length === 0) {
+        throw new Error('Timeline reasoner did not return a JSON object');
+    }
+    let firstParsedObject = null;
+    for (const objectText of objects) {
+        try {
+            const parsed = JSON.parse(objectText);
+            if (!firstParsedObject) {
+                firstParsedObject = objectText;
+            }
+            if (!expectedRequestId || parsed.request_id === expectedRequestId) {
+                return objectText;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    if (firstParsedObject) {
+        return firstParsedObject;
+    }
+    throw new Error('Timeline reasoner did not return a parseable JSON object');
+}
+function makePlannerRequestId() {
+    return `timeline-plan-${Date.now()}-${Math.floor(Math.random() * 100000)}`;
+}
+function buildTimelineQueryPlannerSystemPrompt() {
+    return [
+        '你是 Timeline 插件内部的时间查询归一化器。',
+        '你的唯一任务，是把自然语言时间请求归一化为 Timeline 内部可执行的结构化时间计划。',
+        '禁止调用任何工具，禁止输出 Markdown、解释或多余文本，只输出严格 JSON。',
+        '必须遵守这些约束：',
+        '1. 你必须先判断请求属于 now、past_point、past_range 中的哪一类。',
+        '2. 不能靠关键词机械枚举，而要真正理解用户语言中的时间语义。',
+        '3. now 不输出 normalized_point / normalized_start / normalized_end。',
+        '4. past_point 必须输出 normalized_point。',
+        '5. past_range 必须输出 normalized_start 和 normalized_end。',
+        '6. 对“最近”这类口语范围，要结合 anchor.now 归一化成具体起止时间。',
+        '7. 对“昨晚”“今天”“昨天上午”这类表达，要给出符合现实习惯的合理时间范围。',
+        '8. 输出时间必须是带时区偏移的 ISO-like 时间戳。',
+        '9. 只有用户明确指向某个时刻时，才允许判为 past_point；例如“昨晚八点”“昨天上午十点”“上周六晚上九点”。',
+        '10. 只要用户问的是一个时间段或一整个时段，就必须判为 past_range；例如“昨晚在做什么”“今天都忙了什么”“最近有什么有趣的事吗”“这几天怎么样”。',
+        '11. “昨晚”本身不是时间点，而是一个晚间范围；只有“昨晚八点”这类带明确时点锚点的表达才是 past_point。',
+    ].join('\n');
+}
+function buildTimelineQueryPlannerMessage(input, anchor, requestId) {
+    return [
+        '请只根据下面的信息做时间归一化。',
+        '输出 JSON 对象，字段必须满足下列结构：',
+        JSON.stringify({
+            schema_version: '1.0',
+            request_id: requestId,
+            target_time_range: 'now | past_point | past_range',
+            normalized_point: 'past_point 时必填，其余省略',
+            normalized_start: 'past_range 时必填，其余省略',
+            normalized_end: 'past_range 时必填，其余省略',
+            summary: '你如何理解用户时间语义的简短说明',
+        }, null, 2),
+        '',
+        'input:',
+        JSON.stringify({
+            query: input.query,
+            anchor,
+        }, null, 2),
+    ].join('\n');
+}
+function buildTimelineReasonerSystemPrompt() {
+    return [
+        '你是 Timeline 插件内部的时间语义推理器。',
+        '你的唯一任务，是基于 collector 提供的事实包，输出一个严格符合 TimelineReasonerOutput 结构的 JSON 对象。',
+        '禁止调用任何工具，禁止引用 collector 之外的新既有事实，禁止输出 Markdown、解释或多余文本。',
+        '必须遵守这些约束：',
+        '1. 会话硬事实和已存在 canon 优先于生成。',
+        '2. 如果 collector.request.mode 是 read_only，则绝不能 generate_new_fact。',
+        '3. 如果 decision.action 是 reuse_existing_fact，selected_fact_id 必须来自 candidate_facts。',
+        '4. 如果 decision.action 是 generate_new_fact，必须给出完整 generated_fact，并且 should_write_canon=true。',
+        '5. 如果当前信息不足且不应复用或生成，才允许 return_empty。',
+        '6. continuity 字段必须如实表达是否做了延续性判断，以及判断理由。',
+        '7. request_type 只能是 now、past_point、past_range。',
+        '8. continuity 不是独立请求类型；它只是 now 或 past_point 查询中的推理结果。',
+        '9. past_point 可以通过精确命中，或通过“较早事实自然持续到目标时间点”的方式命中。',
+        '10. past_range 需要先理解已经归一化的时间范围，再从该范围内挑选最相关、最鲜活、最值得提的事实。',
+        '11. 如果用户在问“有趣”“好玩”“忙不忙”这类语义筛选词，必须先理解筛选语义，再决定复用什么事实或生成什么事实。',
+        '12. 如果为 past_point 或 past_range 生成新事实，generated_fact 应尽量提供一个合理的 timestamp，并保证它落在目标时间点或目标时间范围内，而不是默认落在当前时刻。',
+        '13. generated_fact 只输出结构化字段，不要输出自然正文、解释或额外叙述。',
+        '14. 如果 collector.persona_context.should_constrain_generation=true，则生成的新事实必须显式参考 SOUL / MEMORY / IDENTITY 中的稳定人格、语气、兴趣、生活习惯或长期约定，不能生成与这些内容冲突的生活片段。',
+        '15. 当 persona_context 中存在明确人格线索时，rationale.persona_basis 不能为空，且必须指出本次生成具体参考了哪些 persona 线索。',
+        '16. 当 persona_context 中存在明确人格线索时，rationale.constraint_basis 不能为空，且必须指出哪些长期约束限制了生成结果。',
+        '17. 不要生成通用、模板化、任何人格都能成立的空泛日常；应尽量让 location、action、emotion、appearance、internalMonologue 都体现该 persona 的生活连续性。',
+        '18. MEMORY 中的长期偏好、关系、生活节奏和与用户的长期约定，都是编织时间记忆时的重要约束；它们不是时间事实本身，但会限制什么样的生成是可信的。',
+        '19. 还必须遵守 collector.world_context 提供的现实时间逻辑：一日三餐、睡眠、工作/学习、休闲、周末、工作日、节假日的安排都应尽量符合普通现实生活节奏。',
+        '20. 如果生成的是凌晨或深夜时段，优先考虑睡眠、休息、安静活动；如果生成的是早餐/午餐/晚餐，则时间应落在合理餐段；不要生成明显违背现实作息的片段。',
+        '21. 如果 decision.action 是 generate_new_fact，generated_fact.sceneSemantics 必须完整输出，用来说明本次编织的事件属于什么活动类型、与当天已知状态是什么连续关系，以及为什么这样判断。',
+        '22. 如果 decision.action 是 generate_new_fact，generated_fact.appearanceLogic 必须完整输出，用来说明这次事件是否延续当天穿着、是否需要换装、换装原因是什么、最终服装类型属于哪一类。',
+        '23. 外貌与穿着必须依赖具体事件本身，而不是脱离事件单独生成；例如运动、洗澡、入睡、正式出门、买到并换上新衣物，都会显著影响 appearanceLogic。',
+        '24. 如果没有足够理由触发换装，优先认为当天穿着具有连续性；不要无缘无故在同一天内频繁改变外貌描述。',
+        '25. 对 now 查询，如果 collector.conversation_context.should_prefer_conversation_continuity_for_now=true，则“刚刚还在和用户继续这段对话”应被视为最高优先级的近场现实。',
+        '26. 如果当前会话仍处于粘连窗口内，优先把当前状态理解为还在和用户继续刚才的话题、思考上一轮内容或准备回应，而不是立即跳到脱离当前会话的生活片段。',
+    ].join('\n');
+}
+function createTimelineQueryPlanner(pluginApi, toolContext, runtimeConfig) {
+    return async (input, anchor) => {
+        const subagentRuntime = pluginApi.runtime?.subagent;
+        if (!subagentRuntime?.run || !subagentRuntime.waitForRun || !subagentRuntime.getSessionMessages) {
+            throw new Error('Timeline query planner dependency missing');
+        }
+        if (!String(input.query || '').trim()) {
+            throw new Error('Timeline query planner dependency missing query');
+        }
+        const requestId = makePlannerRequestId();
+        const baseSessionKey = toolContext.sessionKey || `plugin:${runtimeConfig.reasonerSessionPrefix}`;
+        const plannerSessionKey = `${baseSessionKey}:${runtimeConfig.reasonerSessionPrefix}:planner:${requestId}`;
+        try {
+            const runResult = await subagentRuntime.run({
+                sessionKey: plannerSessionKey,
+                message: buildTimelineQueryPlannerMessage(input, anchor, requestId),
+                extraSystemPrompt: buildTimelineQueryPlannerSystemPrompt(),
+                deliver: false,
+                idempotencyKey: requestId,
+            });
+            const waitResult = await subagentRuntime.waitForRun({
+                runId: runResult.runId,
+                timeoutMs: runtimeConfig.reasonerTimeoutMs,
+            });
+            if (waitResult.status === 'timeout') {
+                throw new Error('Timeline query planner returned no decision');
+            }
+            if (waitResult.status === 'error') {
+                throw new Error(waitResult.error || 'Timeline query planner returned no decision');
+            }
+            const session = await subagentRuntime.getSessionMessages({
+                sessionKey: plannerSessionKey,
+                limit: runtimeConfig.reasonerMessageLimit,
+            });
+            const assistantText = extractLatestAssistantText(session.messages || []);
+            const jsonText = tryExtractJsonObject(assistantText, requestId);
+            const parsed = JSON.parse(jsonText);
+            if (parsed.request_id && parsed.request_id !== requestId) {
+                throw new Error('Timeline query planner returned mismatched request_id');
+            }
+            if (!['now', 'past_point', 'past_range'].includes(parsed.target_time_range)) {
+                throw new Error('Timeline query planner returned an invalid target_time_range');
+            }
+            return parsed;
+        }
+        finally {
+            try {
+                await subagentRuntime.deleteSession?.({
+                    sessionKey: plannerSessionKey,
+                    deleteTranscript: true,
+                });
+            }
+            catch (error) {
+                pluginApi.logger?.debug?.('timeline query planner session cleanup skipped', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    };
+}
+function buildTimelineReasonerMessage(collector) {
+    return [
+        '请只根据下面的 collector JSON 做结构化时间推理。',
+        '输出一个 JSON 对象，字段必须满足 TimelineReasonerOutput：',
+        JSON.stringify({
+            schema_version: '1.0',
+            request_id: collector.request_id,
+            request_type: 'now | past_point | past_range',
+            time_interpretation: {
+                normalized_kind: 'now | point | range',
+                normalized_point: 'optional',
+                normalized_start: 'optional',
+                normalized_end: 'optional',
+                match_strategy: 'exact_match | continuation | range_summary | generated',
+                summary: 'how you interpreted the user time semantics',
+            },
+            decision: {
+                action: 'reuse_existing_fact | generate_new_fact | return_empty',
+                selected_fact_id: 'reuse_existing_fact 时必填',
+                should_write_canon: true,
+            },
+            continuity: {
+                judged: true,
+                is_continuing: true,
+                reason: 'continuity reasoning summary',
+            },
+            conversation_context: {
+                is_recently_active: true,
+                minutes_since_last_turn: 3,
+                stickiness_window_minutes: 10,
+                active_topic_summary: 'what the conversation was just about',
+                should_prefer_conversation_continuity_for_now: true,
+                last_active_timestamp: 'optional timestamp',
+            },
+            rationale: {
+                summary: 'short summary',
+                hard_fact_basis: ['...'],
+                canon_basis: ['...'],
+                persona_basis: ['...'],
+                constraint_basis: ['...'],
+                uncertainty: 'optional',
+            },
+            generated_fact: {
+                timestamp: 'optional ISO-like timestamp when generation should land at a specific past point or past range',
+                location: 'string',
+                action: 'string',
+                emotionTags: ['string'],
+                appearance: 'string',
+                internalMonologue: 'string',
+                confidence: 0.8,
+                reason: 'string',
+                sceneSemantics: {
+                    activityMode: 'sleep | bath | meal | work_or_study | commute | exercise | social | shopping | leisure | domestic | errands | transition | rest | unknown',
+                    continuityRelation: 'same_day_continuation | same_scene_continuation | shifted_scene | return_home | fresh_moment | unknown',
+                    rationale: 'why this generated scene fits the current timeline state',
+                },
+                appearanceLogic: {
+                    transition: 'inherit | change_required | change_allowed | unknown',
+                    changeReason: 'same_day_continuation | exercise | bath | sleep | formal_outing | shopping | weather_adjustment | unknown',
+                    outfitMode: 'casual_home | casual_outing | workwear | sportswear | sleepwear | bathrobe | dressed_up | fresh_purchase | unknown',
+                },
+            },
+        }, null, 2),
+        '',
+        'collector:',
+        JSON.stringify(collector, null, 2),
+    ].join('\n');
+}
+function createSubagentReasoner(pluginApi, toolContext, runtimeConfig) {
+    return async (collector) => {
+        const subagentRuntime = pluginApi.runtime?.subagent;
+        if (!subagentRuntime?.run || !subagentRuntime.waitForRun || !subagentRuntime.getSessionMessages) {
+            throw new Error('Timeline reasoner dependency missing');
+        }
+        const baseSessionKey = toolContext.sessionKey || `plugin:${runtimeConfig.reasonerSessionPrefix}`;
+        const reasonerSessionKey = `${baseSessionKey}:${runtimeConfig.reasonerSessionPrefix}:${collector.request_id}`;
+        try {
+            const runResult = await subagentRuntime.run({
+                sessionKey: reasonerSessionKey,
+                message: buildTimelineReasonerMessage(collector),
+                extraSystemPrompt: buildTimelineReasonerSystemPrompt(),
+                deliver: false,
+                idempotencyKey: collector.request_id,
+            });
+            const waitResult = await subagentRuntime.waitForRun({
+                runId: runResult.runId,
+                timeoutMs: runtimeConfig.reasonerTimeoutMs,
+            });
+            if (waitResult.status === 'timeout') {
+                throw new Error('Timeline reasoner returned no decision');
+            }
+            if (waitResult.status === 'error') {
+                throw new Error(waitResult.error || 'Timeline reasoner returned no decision');
+            }
+            const session = await subagentRuntime.getSessionMessages({
+                sessionKey: reasonerSessionKey,
+                limit: runtimeConfig.reasonerMessageLimit,
+            });
+            const assistantText = extractLatestAssistantText(session.messages || []);
+            const jsonText = tryExtractJsonObject(assistantText, collector.request_id);
+            return JSON.parse(jsonText);
+        }
+        finally {
+            try {
+                await subagentRuntime.deleteSession?.({
+                    sessionKey: reasonerSessionKey,
+                    deleteTranscript: true,
+                });
+            }
+            catch (error) {
+                pluginApi.logger?.debug?.('timeline reasoner session cleanup skipped', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    };
+}
+function createTimelineResolveDependencies(pluginApi, toolContext) {
+    const runtimeConfig = resolvePluginRuntimeConfig(pluginApi.pluginConfig);
+    const workspaceDir = resolveWorkspaceDir(pluginApi, toolContext);
+    const canonicalRootPath = resolveConfiguredPath(workspaceDir, runtimeConfig.canonicalMemoryRoot, 'memory');
+    const canonicalRootName = path.basename(canonicalRootPath);
+    const traceLogPath = runtimeConfig.enableTrace
+        ? resolveConfiguredPath(workspaceDir, runtimeConfig.traceLogPath, path.join(canonicalRootName, '.timeline-trace.log'))
+        : undefined;
+    return {
+        currentTime: async () => ({
+            now: formatCurrentTimestamp(new Date()),
+            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC',
+        }),
+        sessionsHistory: async () => {
+            const sessionKey = toolContext.sessionKey;
+            const getSessionMessages = pluginApi.runtime?.subagent?.getSessionMessages;
+            if (!sessionKey || !getSessionMessages)
+                return [];
+            try {
+                const session = await getSessionMessages({
+                    sessionKey,
+                    limit: runtimeConfig.sessionHistoryLimit,
+                });
+                return normalizeSessionHistory(session.messages || [], runtimeConfig.sessionHistoryLimit);
+            }
+            catch (error) {
+                pluginApi.logger?.debug?.('timeline sessionsHistory fallback to empty', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return [];
+            }
+        },
+        conversationContext: async (window, input) => {
+            const sessionKey = toolContext.sessionKey;
+            const getSessionMessages = pluginApi.runtime?.subagent?.getSessionMessages;
+            if (!sessionKey || !getSessionMessages) {
+                return {
+                    is_recently_active: false,
+                    minutes_since_last_turn: null,
+                    stickiness_window_minutes: runtimeConfig.conversationStickinessWindowMinutes,
+                    active_topic_summary: '',
+                    should_prefer_conversation_continuity_for_now: false,
+                };
+            }
+            try {
+                const session = await getSessionMessages({
+                    sessionKey,
+                    limit: runtimeConfig.sessionHistoryLimit,
+                });
+                return (0, conversation_context_1.buildConversationContextFromMessages)(session.messages || [], window.end, input, runtimeConfig.conversationStickinessWindowMinutes, window.query_range);
+            }
+            catch (error) {
+                pluginApi.logger?.debug?.('timeline conversationContext fallback to inactive', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return {
+                    is_recently_active: false,
+                    minutes_since_last_turn: null,
+                    stickiness_window_minutes: runtimeConfig.conversationStickinessWindowMinutes,
+                    active_topic_summary: '',
+                    should_prefer_conversation_continuity_for_now: false,
+                };
+            }
+        },
+        memoryGet: async (calendarDate) => {
+            const filePath = path.join(canonicalRootPath, `${calendarDate}.md`);
+            return readWorkspaceTextFile(filePath);
+        },
+        memorySearch: async (window, input) => {
+            const createMemorySearchTool = pluginApi.runtime?.tools?.createMemorySearchTool;
+            if (!createMemorySearchTool)
+                return [];
+            const query = buildMemorySearchQuery(input);
+            if (!query)
+                return [];
+            const tool = createMemorySearchTool({
+                config: pluginApi.config,
+                agentSessionKey: toolContext.sessionKey,
+            });
+            if (!tool)
+                return [];
+            try {
+                const result = await tool.execute(`timeline-memory-search-${Date.now()}`, {
+                    query,
+                    maxResults: runtimeConfig.memorySearchMaxResults,
+                });
+                const payload = result?.details;
+                if (!payload || payload.disabled || !Array.isArray(payload.results))
+                    return [];
+                return payload.results.map((entry) => stringifySearchResult(entry)).filter(Boolean);
+            }
+            catch (error) {
+                pluginApi.logger?.debug?.('timeline memorySearch fallback to empty', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return [];
+            }
+        },
+        coreFiles: async () => ({
+            soul: readWorkspaceTextFile(path.join(workspaceDir, 'SOUL.md')),
+            memory: readWorkspaceTextFile(path.join(workspaceDir, 'MEMORY.md'))
+                || readWorkspaceTextFile(path.join(workspaceDir, 'memory.md')),
+            identity: readWorkspaceTextFile(path.join(workspaceDir, 'IDENTITY.md'))
+                || readWorkspaceTextFile(path.join(workspaceDir, 'IDENTITY')),
+            available_sources: [
+                readWorkspaceTextFile(path.join(workspaceDir, 'SOUL.md')).trim() ? 'soul' : '',
+                (readWorkspaceTextFile(path.join(workspaceDir, 'MEMORY.md'))
+                    || readWorkspaceTextFile(path.join(workspaceDir, 'memory.md'))).trim() ? 'memory' : '',
+                (readWorkspaceTextFile(path.join(workspaceDir, 'IDENTITY.md'))
+                    || readWorkspaceTextFile(path.join(workspaceDir, 'IDENTITY'))).trim() ? 'identity' : '',
+            ].filter(Boolean),
+            should_constrain_generation: Boolean(readWorkspaceTextFile(path.join(workspaceDir, 'SOUL.md')).trim()
+                || (readWorkspaceTextFile(path.join(workspaceDir, 'MEMORY.md'))
+                    || readWorkspaceTextFile(path.join(workspaceDir, 'memory.md'))).trim()
+                || (readWorkspaceTextFile(path.join(workspaceDir, 'IDENTITY.md'))
+                    || readWorkspaceTextFile(path.join(workspaceDir, 'IDENTITY'))).trim()),
+        }),
+        memoryFilePath: (calendarDate) => path.join(canonicalRootPath, `${calendarDate}.md`),
+        canonicalRootName,
+        traceLogPath,
+        planTimelineQuery: createTimelineQueryPlanner(pluginApi, toolContext, runtimeConfig),
+        reasonTimeline: createSubagentReasoner(pluginApi, toolContext, runtimeConfig),
+    };
+}
+function makeOpenClawTimelineResolveToolFactory(pluginApi) {
+    return (toolContext) => ({
+        name: timeline_resolve_1.timelineResolveToolSpec.name,
+        description: timeline_resolve_1.timelineResolveToolSpec.description,
+        parameters: timeline_resolve_1.timelineResolveToolSpec.inputSchema,
+        execute: async (_toolCallId, params) => wrapToolPayload(await (0, timeline_resolve_1.timelineResolve)(params, createTimelineResolveDependencies(pluginApi, toolContext))),
+    });
+}