stella-timeline-plugin 2.0.0 → 2.0.2

package/dist/src/runtime/openclaw_timeline_runtime.js

@@ -37,6 +37,7 @@ exports.makeOpenClawTimelineResolveToolFactory = makeOpenClawTimelineResolveTool
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const conversation_context_1 = require("./conversation_context");
+const time_utils_1 = require("../lib/time-utils");
 const timeline_resolve_1 = require("../tools/timeline_resolve");
 function readString(value) {
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;
@@ -52,7 +53,7 @@ function resolvePluginRuntimeConfig(pluginConfig) {
         enableTrace: readBoolean(pluginConfig?.enableTrace, true),
         traceLogPath: readString(pluginConfig?.traceLogPath),
         canonicalMemoryRoot: readString(pluginConfig?.canonicalMemoryRoot) || 'memory',
-        reasonerTimeoutMs: readInteger(pluginConfig?.reasonerTimeoutMs, 45000),
+        reasonerTimeoutMs: readInteger(pluginConfig?.reasonerTimeoutMs, 90000),
         reasonerSessionPrefix: readString(pluginConfig?.reasonerSessionPrefix) || 'timeline-reasoner',
         reasonerMessageLimit: readInteger(pluginConfig?.reasonerMessageLimit, 24),
         sessionHistoryLimit: readInteger(pluginConfig?.sessionHistoryLimit, 12),
@@ -183,9 +184,7 @@ function normalizeSessionHistory(messages, limit) {
 function extractLatestAssistantText(messages) {
     const reversed = [...messages].reverse();
     for (const message of reversed) {
-        const role = typeof message?.role === 'string'
-            ? String(message.role).trim()
-            : '';
+        const role = extractMessageRole(message);
         const text = extractMessageText(message);
         if (role === 'assistant' && text)
             return text;
@@ -240,12 +239,12 @@ function collectBalancedJsonObjects(text) {
     }
     return objects;
 }
-function tryExtractJsonObject(text, expectedRequestId) {
+function tryExtractJsonObject(text, sourceLabel, 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');
+        throw new Error(`${sourceLabel} did not return a JSON object`);
     }
     let firstParsedObject = null;
     for (const objectText of objects) {
@@ -262,45 +261,91 @@ function tryExtractJsonObject(text, expectedRequestId) {
             continue;
         }
     }
-    if (firstParsedObject) {
+    if (firstParsedObject && !expectedRequestId) {
         return firstParsedObject;
     }
-    throw new Error('Timeline reasoner did not return a parseable JSON object');
+    if (firstParsedObject && expectedRequestId) {
+        throw new Error(`${sourceLabel} returned mismatched request_id`);
+    }
+    throw new Error(`${sourceLabel} did not return a parseable JSON object`);
+}
+function collectRelevantTranscriptTexts(messages) {
+    return [...messages]
+        .reverse()
+        .map((message) => ({
+        role: extractMessageRole(message),
+        text: extractMessageText(message),
+    }))
+        .filter((entry) => Boolean(entry.text))
+        .filter((entry) => entry.role === 'assistant' || entry.role === 'unknown');
+}
+function extractJsonObjectFromMessages(messages, sourceLabel, expectedRequestId) {
+    const relevantMessages = collectRelevantTranscriptTexts(messages);
+    let sawMismatchedRequestId = false;
+    let sawJsonLikeOutput = false;
+    for (const entry of relevantMessages) {
+        try {
+            return tryExtractJsonObject(entry.text, sourceLabel, expectedRequestId);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes('mismatched request_id')) {
+                sawMismatchedRequestId = true;
+                sawJsonLikeOutput = true;
+                continue;
+            }
+            if (message.includes('parseable JSON object')) {
+                sawJsonLikeOutput = true;
+                continue;
+            }
+            if (message.includes('did not return a JSON object')) {
+                continue;
+            }
+            throw error;
+        }
+    }
+    if (sawMismatchedRequestId) {
+        throw new Error(`${sourceLabel} returned mismatched request_id`);
+    }
+    if (sawJsonLikeOutput) {
+        throw new Error(`${sourceLabel} did not return a parseable JSON object`);
+    }
+    throw new Error(`${sourceLabel} did not return a 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。',
+        'You are the internal Timeline plugin query normalizer.',
+        'Your only task is to normalize a natural-language time request into a structured time plan that Timeline can execute.',
+        'Do not call tools. Do not output Markdown, explanations, or extra text. Output strict JSON only.',
+        'You must follow these constraints:',
+        '1. First classify the request as now, past_point, or past_range.',
+        '2. Do not classify mechanically from keywords. Interpret the actual time semantics in the user request.',
+        '3. For now, do not output normalized_point / normalized_start / normalized_end.',
+        '4. For past_point, normalized_point is required.',
+        '5. For past_range, normalized_start and normalized_end are required.',
+        '6. For colloquial ranges such as “最近”, normalize into concrete bounds using anchor.now.',
+        '7. For expressions such as “昨晚”, “今天”, or “昨天上午”, produce a realistic range that fits ordinary usage.',
+        '8. All output times must be ISO-like timestamps with timezone offsets.',
+        '9. Classify as past_point only when the user clearly points to a specific moment, for example “昨晚八点”, “昨天上午十点”, or “上周六晚上九点”.',
+        '10. If the user is asking about a duration or a whole period, it must be past_range, for example “昨晚在做什么”, “今天都忙了什么”, “最近有什么有趣的事吗”, or “这几天怎么样”.',
+        '11. “昨晚” by itself is not a point in time. It is an evening range. Only expressions with an explicit anchor such as “昨晚八点” are past_point.',
     ].join('\n');
 }
 function buildTimelineQueryPlannerMessage(input, anchor, requestId) {
     return [
-        '请只根据下面的信息做时间归一化。',
-        '输出 JSON 对象，字段必须满足下列结构：',
+        'Normalize time only from the information below.',
+        'Output a JSON object with the following shape:',
         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: '你如何理解用户时间语义的简短说明',
+            normalized_point: 'required for past_point, omit otherwise',
+            normalized_start: 'required for past_range, omit otherwise',
+            normalized_end: 'required for past_range, omit otherwise',
+            summary: 'short summary of how you interpreted the user time semantics',
         }, null, 2),
         '',
         'input:',
@@ -312,102 +357,333 @@ function buildTimelineQueryPlannerMessage(input, anchor, requestId) {
 }
 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. 如果当前会话仍处于粘连窗口内，优先把当前状态理解为还在和用户继续刚才的话题、思考上一轮内容或准备回应，而不是立即跳到脱离当前会话的生活片段。',
+        'You are the internal Timeline plugin time-semantics reasoner.',
+        'Your only task is to use the collector fact bundle and output a JSON object that strictly matches TimelineReasonerOutput.',
+        'Do not call tools. Do not introduce pre-existing facts beyond the collector input. Do not output Markdown, explanations, or extra text.',
+        'You must follow these constraints:',
+        '1. Session hard facts and existing canon facts take priority over generation.',
+        '2. If collector.request.mode is read_only, you must never generate_new_fact.',
+        '3. If decision.action is reuse_existing_fact, selected_fact_id must come from candidate_facts.',
+        '4. If decision.action is generate_new_fact, you must provide a complete generated_fact and set should_write_canon=true.',
+        '5. Use return_empty only when the available information is insufficient and neither reuse nor generation is justified.',
+        '6. The continuity field must truthfully report whether continuity reasoning was used and why.',
+        '7. request_type must be one of now, past_point, or past_range.',
+        '8. continuity is not a separate request type. It is a reasoning result inside now or past_point queries.',
+        '9. past_point may hit either by exact match or by a prior fact that naturally continues to the target time.',
+        '10. For past_range, first understand the normalized range, then choose the most relevant, vivid, and worth-mentioning facts from that range.',
+        '11. If the user asks with semantic filters such as “有趣”, “好玩”, or “忙不忙”, interpret that filter first before deciding which fact to reuse or generate.',
+        '12. When generating a new fact for past_point or past_range, provide a reasonable timestamp that lands inside the target point or range instead of defaulting to the current moment.',
+        '13. generated_fact must contain structured fields only, with no free-form prose, explanation, or extra narration.',
+        '14. If collector.persona_context.should_constrain_generation=true, the new fact must explicitly respect the stable persona, tone, interests, habits, and long-term commitments described in SOUL / MEMORY / IDENTITY, and must not conflict with them.',
+        '15. When persona_context contains concrete persona signals, rationale.persona_basis must be non-empty and must name the specific persona signals used.',
+        '16. When persona_context contains concrete persona signals, rationale.constraint_basis must be non-empty and must name the long-term constraints that limited generation.',
+        '17. Do not generate generic, template-like daily scenes that could fit anyone. Let location, action, emotion, appearance, and internalMonologue reflect this persona\'s lived continuity.',
+        '18. Long-term preferences, relationships, life rhythm, and standing commitments from MEMORY are important constraints when weaving time memories. They are not time facts themselves, but they constrain what generation is believable.',
+        '19. You must also respect the real-world temporal logic in collector.world_context: meals, sleep, work/study, leisure, weekends, weekdays, and holidays should broadly fit ordinary life rhythm.',
+        '20. For late-night or pre-dawn generation, prefer sleep, rest, or quiet activities. For breakfast, lunch, or dinner scenes, keep the timestamp inside a plausible meal window. Do not generate scenes that obviously violate ordinary routine.',
+        '21. If decision.action is generate_new_fact, generated_fact.sceneSemantics must be fully populated to explain the activity type, how it relates to known same-day state, and why that judgment fits.',
+        '22. If decision.action is generate_new_fact, generated_fact.appearanceLogic must be fully populated to explain whether the day\'s outfit continues, whether a change is needed, why, and what outfit class results.',
+        '23. Appearance and clothing must depend on the concrete event itself rather than being generated independently. Exercise, bathing, sleep, formal outings, and buying/changing into new clothes are all strong appearance drivers.',
+        '24. If there is not enough reason for an outfit change, prefer same-day clothing continuity. Do not change appearance descriptions repeatedly within one day without cause.',
+        '25. For now queries, if collector.conversation_context.should_prefer_conversation_continuity_for_now=true, then “still continuing the just-active conversation with the user” should be treated as the highest-priority near-field reality.',
+        '26. If the current session is still inside the stickiness window, prefer interpreting the current state as continuing the recent topic, thinking about the last turn, or preparing a response, instead of jumping immediately to an unrelated off-thread life scene.',
     ].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');
+function setClock(parts, hour, minute = 0, second = 0) {
+    return {
+        ...parts,
+        hour,
+        minute,
+        second,
+    };
+}
+function normalizeHourFromQuery(query) {
+    const digitMatch = query.match(/(\d{1,2})点/);
+    let hour = digitMatch ? Number(digitMatch[1]) : null;
+    if (hour === null) {
+        const chineseHourMap = {
+            零: 0,
+            一: 1,
+            二: 2,
+            两: 2,
+            三: 3,
+            四: 4,
+            五: 5,
+            六: 6,
+            七: 7,
+            八: 8,
+            九: 9,
+            十: 10,
+            十一: 11,
+            十二: 12,
+        };
+        const chineseMatch = query.match(/(十一|十二|十|零|一|二|两|三|四|五|六|七|八|九)点/);
+        if (chineseMatch) {
+            hour = chineseHourMap[chineseMatch[1]] ?? null;
         }
-        if (!String(input.query || '').trim()) {
-            throw new Error('Timeline query planner dependency missing query');
+    }
+    if (hour === null)
+        return null;
+    if ((/昨晚|晚上|傍晚|夜里/.test(query)) && hour < 12) {
+        return hour === 12 ? 12 : hour + 12;
+    }
+    if ((/下午/.test(query)) && hour < 12) {
+        return hour === 12 ? 12 : hour + 12;
+    }
+    return hour;
+}
+function buildFallbackTimelineQueryPlan(input, anchor) {
+    const query = String(input.query || '').trim();
+    const anchorParts = (0, time_utils_1.parseTimestampParts)(anchor.now);
+    if (!anchorParts) {
+        return {
+            schema_version: '1.0',
+            target_time_range: 'now',
+            summary: 'Fallback planner defaulted to now because anchor.now was not parseable.',
+        };
+    }
+    if (/昨晚|昨天|上周|前天/.test(query) && /点/.test(query)) {
+        const targetHour = normalizeHourFromQuery(query) ?? 20;
+        const targetDay = (0, time_utils_1.addHours)(anchorParts, -24);
+        return {
+            schema_version: '1.0',
+            target_time_range: 'past_point',
+            normalized_point: (0, time_utils_1.formatTimestamp)(setClock(targetDay, targetHour, 0, 0)),
+            summary: 'Fallback planner normalized the query into a concrete past point.',
+        };
+    }
+    if (/最近|这几天|昨晚|今天都|昨天都/.test(query)) {
+        if (/昨晚/.test(query)) {
+            const targetDay = (0, time_utils_1.addHours)(anchorParts, -24);
+            return {
+                schema_version: '1.0',
+                target_time_range: 'past_range',
+                normalized_start: (0, time_utils_1.formatTimestamp)(setClock(targetDay, 18, 0, 0)),
+                normalized_end: (0, time_utils_1.formatTimestamp)(setClock(targetDay, 23, 59, 59)),
+                summary: 'Fallback planner normalized the query into last night\'s evening range.',
+            };
         }
-        const requestId = makePlannerRequestId();
-        const baseSessionKey = toolContext.sessionKey || `plugin:${runtimeConfig.reasonerSessionPrefix}`;
-        const plannerSessionKey = `${baseSessionKey}:${runtimeConfig.reasonerSessionPrefix}:planner:${requestId}`;
+        const recentStart = (0, time_utils_1.addHours)(anchorParts, -24 * 7);
+        return {
+            schema_version: '1.0',
+            target_time_range: 'past_range',
+            normalized_start: (0, time_utils_1.formatTimestamp)(setClock(recentStart, 0, 0, 0)),
+            normalized_end: anchor.now,
+            summary: 'Fallback planner normalized the query into a recent past range.',
+        };
+    }
+    return {
+        schema_version: '1.0',
+        target_time_range: 'now',
+        summary: 'Fallback planner normalized the query into the current moment.',
+    };
+}
+function parseTimestampMs(timestamp) {
+    if (!timestamp)
+        return Number.NaN;
+    const parsed = Date.parse(timestamp);
+    return Number.isNaN(parsed) ? Number.NaN : parsed;
+}
+function selectLatestFact(facts) {
+    return [...facts]
+        .sort((left, right) => parseTimestampMs(right.timestamp) - parseTimestampMs(left.timestamp))[0] || null;
+}
+function scorePastRangeFact(fact, query) {
+    let score = parseTimestampMs(fact.timestamp);
+    const haystack = `${fact.location} ${fact.action} ${(fact.emotion_tags || []).join(' ')}`;
+    if (/有趣|好玩|开心|趣事/.test(query) && /(朋友|球|篮球|烧烤|聊天|公园|运动|开心)/.test(haystack)) {
+        score += 1000 * 60 * 60 * 24 * 30;
+    }
+    if (/昨晚/.test(query)) {
+        const parts = (0, time_utils_1.parseTimestampParts)(fact.timestamp);
+        if (parts && parts.hour >= 18 && parts.hour <= 23) {
+            score += 1000 * 60 * 60 * 12;
+        }
+    }
+    return score;
+}
+function selectFallbackFact(collector) {
+    const facts = collector.candidate_facts || [];
+    if (facts.length === 0)
+        return null;
+    if (collector.window.query_range === 'now') {
+        return selectLatestFact(facts);
+    }
+    if (collector.window.query_range === 'past_point') {
+        const query = String(collector.request.user_query || '');
+        const explicitHour = normalizeHourFromQuery(query);
+        if (explicitHour === null) {
+            return selectLatestFact(facts);
+        }
+        return [...facts].sort((left, right) => {
+            const leftParts = (0, time_utils_1.parseTimestampParts)(left.timestamp);
+            const rightParts = (0, time_utils_1.parseTimestampParts)(right.timestamp);
+            const leftDistance = leftParts ? Math.abs((leftParts.hour * 60 + leftParts.minute) - explicitHour * 60) : Number.MAX_SAFE_INTEGER;
+            const rightDistance = rightParts ? Math.abs((rightParts.hour * 60 + rightParts.minute) - explicitHour * 60) : Number.MAX_SAFE_INTEGER;
+            return leftDistance - rightDistance || (parseTimestampMs(right.timestamp) - parseTimestampMs(left.timestamp));
+        })[0] || null;
+    }
+    const query = String(collector.request.user_query || '');
+    return [...facts].sort((left, right) => scorePastRangeFact(right, query) - scorePastRangeFact(left, query))[0] || null;
+}
+function buildFallbackTimeInterpretation(collector, selectedFact) {
+    if (collector.window.query_range === 'now') {
+        return {
+            normalized_kind: 'now',
+            match_strategy: selectedFact ? 'continuation' : 'generated',
+            summary: 'Fallback reasoner treated the request as a current-moment query.',
+        };
+    }
+    if (collector.window.query_range === 'past_point') {
+        const query = String(collector.request.user_query || '');
+        const hour = normalizeHourFromQuery(query);
+        const anchorParts = (0, time_utils_1.parseTimestampParts)(collector.anchor.now);
+        const targetDay = anchorParts ? (0, time_utils_1.addHours)(anchorParts, -24) : null;
+        return {
+            normalized_kind: 'point',
+            normalized_point: targetDay && hour !== null ? (0, time_utils_1.formatTimestamp)(setClock(targetDay, hour, 0, 0)) : selectedFact?.timestamp,
+            match_strategy: selectedFact ? 'continuation' : 'generated',
+            summary: 'Fallback reasoner treated the request as a concrete past point query.',
+        };
+    }
+    return {
+        normalized_kind: 'range',
+        normalized_start: collector.window.start,
+        normalized_end: collector.window.end,
+        match_strategy: selectedFact ? 'range_summary' : 'generated',
+        summary: 'Fallback reasoner treated the request as a past range query.',
+    };
+}
+function buildFallbackReasonerOutput(collector, error) {
+    const selectedFact = selectFallbackFact(collector);
+    const fallbackReason = error instanceof Error ? error.message : String(error);
+    if (!selectedFact) {
+        return {
+            schema_version: '1.0',
+            request_id: collector.request_id,
+            request_type: collector.window.query_range,
+            time_interpretation: buildFallbackTimeInterpretation(collector, null),
+            decision: {
+                action: 'return_empty',
+                should_write_canon: false,
+            },
+            continuity: {
+                judged: collector.window.query_range !== 'past_range',
+                is_continuing: false,
+                reason: `Fallback reasoner could not find a reusable canon fact after: ${fallbackReason}`,
+            },
+            rationale: {
+                summary: 'Fallback reasoner returned empty because no reusable canon fact was available.',
+                hard_fact_basis: collector.hard_facts.sessions_history.slice(0, 2),
+                canon_basis: [],
+                persona_basis: [],
+                constraint_basis: [],
+                uncertainty: fallbackReason,
+            },
+        };
+    }
+    const selectedParts = (0, time_utils_1.parseTimestampParts)(selectedFact.timestamp);
+    const targetHour = normalizeHourFromQuery(String(collector.request.user_query || ''));
+    const isPastPointContinuation = Boolean(collector.window.query_range === 'past_point'
+        && selectedParts
+        && targetHour !== null
+        && Math.abs((selectedParts.hour * 60 + selectedParts.minute) - targetHour * 60) <= 90);
+    return {
+        schema_version: '1.0',
+        request_id: collector.request_id,
+        request_type: collector.window.query_range,
+        time_interpretation: buildFallbackTimeInterpretation(collector, selectedFact),
+        decision: {
+            action: 'reuse_existing_fact',
+            selected_fact_id: selectedFact.fact_id,
+            should_write_canon: false,
+        },
+        continuity: {
+            judged: collector.window.query_range !== 'past_range',
+            is_continuing: collector.window.query_range === 'now' || isPastPointContinuation,
+            reason: 'Fallback reasoner reused the strongest available canon fact when the subagent result was unavailable.',
+        },
+        rationale: {
+            summary: 'Fallback reasoner reused an existing canon fact because the subagent result was unavailable or invalid.',
+            hard_fact_basis: collector.hard_facts.sessions_history.slice(0, 2),
+            canon_basis: [selectedFact.fact_id],
+            persona_basis: [],
+            constraint_basis: [],
+            uncertainty: fallbackReason,
+        },
+    };
+}
+function createTimelineQueryPlanner(pluginApi, toolContext, runtimeConfig) {
+    return async (input, anchor) => {
         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 subagentRuntime = pluginApi.runtime?.subagent;
+            if (!subagentRuntime?.run || !subagentRuntime.waitForRun || !subagentRuntime.getSessionMessages) {
+                throw new Error('Timeline query planner dependency missing');
             }
-            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');
+            if (!String(input.query || '').trim()) {
+                throw new Error('Timeline query planner dependency missing query');
             }
-            return parsed;
-        }
-        finally {
+            const requestId = makePlannerRequestId();
+            const baseSessionKey = toolContext.sessionKey || `plugin:${runtimeConfig.reasonerSessionPrefix}`;
+            const plannerSessionKey = `${baseSessionKey}:${runtimeConfig.reasonerSessionPrefix}:planner:${requestId}`;
             try {
-                await subagentRuntime.deleteSession?.({
+                const runResult = await subagentRuntime.run({
                     sessionKey: plannerSessionKey,
-                    deleteTranscript: true,
+                    message: buildTimelineQueryPlannerMessage(input, anchor, requestId),
+                    extraSystemPrompt: buildTimelineQueryPlannerSystemPrompt(),
+                    deliver: false,
+                    idempotencyKey: requestId,
                 });
-            }
-            catch (error) {
-                pluginApi.logger?.debug?.('timeline query planner session cleanup skipped', {
-                    error: error instanceof Error ? error.message : String(error),
+                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 jsonText = extractJsonObjectFromMessages(session.messages || [], 'Timeline query planner', 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),
+                    });
+                }
             }
         }
+        catch (error) {
+            pluginApi.logger?.warn?.('timeline query planner fallback engaged', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return buildFallbackTimelineQueryPlan(input, anchor);
+        }
     };
 }
 function buildTimelineReasonerMessage(collector) {
     return [
-        '请只根据下面的 collector JSON 做结构化时间推理。',
-        '输出一个 JSON 对象，字段必须满足 TimelineReasonerOutput：',
+        'Perform structured time reasoning using only the collector JSON below.',
+        'Output a JSON object matching TimelineReasonerOutput:',
         JSON.stringify({
             schema_version: '1.0',
             request_id: collector.request_id,
@@ -422,7 +698,7 @@ function buildTimelineReasonerMessage(collector) {
             },
             decision: {
                 action: 'reuse_existing_fact | generate_new_fact | return_empty',
-                selected_fact_id: 'reuse_existing_fact 时必填',
+                selected_fact_id: 'required when action is reuse_existing_fact',
                 should_write_canon: true,
             },
             continuity: {
@@ -474,50 +750,57 @@ function buildTimelineReasonerMessage(collector) {
 }
 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 subagentRuntime = pluginApi.runtime?.subagent;
+            if (!subagentRuntime?.run || !subagentRuntime.waitForRun || !subagentRuntime.getSessionMessages) {
+                throw new Error('Timeline reasoner dependency missing');
             }
-            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 {
+            const baseSessionKey = toolContext.sessionKey || `plugin:${runtimeConfig.reasonerSessionPrefix}`;
+            const reasonerSessionKey = `${baseSessionKey}:${runtimeConfig.reasonerSessionPrefix}:${collector.request_id}`;
             try {
-                await subagentRuntime.deleteSession?.({
+                const runResult = await subagentRuntime.run({
                     sessionKey: reasonerSessionKey,
-                    deleteTranscript: true,
+                    message: buildTimelineReasonerMessage(collector),
+                    extraSystemPrompt: buildTimelineReasonerSystemPrompt(),
+                    deliver: false,
+                    idempotencyKey: collector.request_id,
                 });
-            }
-            catch (error) {
-                pluginApi.logger?.debug?.('timeline reasoner session cleanup skipped', {
-                    error: error instanceof Error ? error.message : String(error),
+                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 jsonText = extractJsonObjectFromMessages(session.messages || [], 'Timeline reasoner', 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),
+                    });
+                }
+            }
+        }
+        catch (error) {
+            pluginApi.logger?.warn?.('timeline reasoner fallback engaged', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return buildFallbackReasonerOutput(collector, error);
         }
     };
 }