stella-timeline-plugin 2.0.0 → 2.0.2

package/scripts/run-openclaw-smoke.mjs

@@ -1,21 +1,296 @@
-import { spawnSync } from 'node:child_process';
+import { execSync, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
 import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const runtimeTempDir = process.platform === 'win32' ? os.tmpdir() : '/tmp';
 
-const result = spawnSync(
-  process.execPath,
-  ['node_modules/jest/bin/jest.js', '--runInBand', '--runTestsByPath', 'src/integration/openclaw-runtime.smoke.test.ts'],
-  {
-    stdio: 'inherit',
+function runCapture(command) {
+  try {
+    return execSync(command, {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      env: {
+        ...process.env,
+        TMPDIR: runtimeTempDir,
+        TMP: runtimeTempDir,
+        TEMP: runtimeTempDir,
+      },
+    }).trim();
+  } catch {
+    return '';
+  }
+}
+
+function resolveOnPath(binaryName) {
+  const command = process.platform === 'win32' ? 'where' : 'which';
+  const result = spawnSync(command, [binaryName], {
+    encoding: 'utf8',
     env: {
       ...process.env,
       TMPDIR: runtimeTempDir,
       TMP: runtimeTempDir,
       TEMP: runtimeTempDir,
-      OPENCLAW_RUNTIME_SMOKE: '1',
     },
+  });
+  if (result.status !== 0) return '';
+  return result.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find(Boolean) || '';
+}
+
+function listJsFiles(dirPath) {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listJsFiles(fullPath));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith('.js')) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+function candidateDistDirs() {
+  const dirs = new Set();
+  const explicit = process.env.OPENCLAW_RUNTIME_MODULE?.trim();
+  if (explicit && fs.existsSync(explicit)) {
+    dirs.add(path.dirname(explicit));
+  }
+
+  const npmRoot = runCapture(process.platform === 'win32' ? 'npm.cmd root -g' : 'npm root -g');
+  if (npmRoot) {
+    dirs.add(path.join(npmRoot, 'openclaw', 'dist'));
+  }
+
+  const npmPrefix = runCapture(process.platform === 'win32' ? 'npm.cmd prefix -g' : 'npm prefix -g');
+  if (npmPrefix) {
+    dirs.add(path.join(npmPrefix, 'node_modules', 'openclaw', 'dist'));
+    dirs.add(path.join(npmPrefix, 'lib', 'node_modules', 'openclaw', 'dist'));
+  }
+
+  const openClawBin = resolveOnPath('openclaw');
+  if (openClawBin) {
+    const binDir = path.dirname(openClawBin);
+    dirs.add(path.join(binDir, 'node_modules', 'openclaw', 'dist'));
+    dirs.add(path.join(binDir, '..', 'node_modules', 'openclaw', 'dist'));
+    dirs.add(path.join(binDir, '..', 'lib', 'node_modules', 'openclaw', 'dist'));
+  }
+
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA?.trim();
+    if (appData) {
+      dirs.add(path.join(appData, 'npm', 'node_modules', 'openclaw', 'dist'));
+    }
+  }
+
+  return [...dirs];
+}
+
+function findRuntimeModuleInDist(distDir) {
+  if (!fs.existsSync(distDir)) return '';
+  const candidates = listJsFiles(distDir);
+  const aliasAware = candidates.find((filePath) => {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return content.includes('loadOpenClawPlugins as') && content.includes('resolvePluginTools as');
+  });
+  if (aliasAware) return aliasAware;
+
+  const direct = candidates.find((filePath) => {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return content.includes('function loadOpenClawPlugins') && content.includes('function resolvePluginTools');
+  });
+  if (direct) return direct;
+
+  return candidates.find((filePath) => /^reply-.*\.js$/.test(path.basename(filePath))) || '';
+}
+
+function findOpenClawRuntimeModule() {
+  const explicit = process.env.OPENCLAW_RUNTIME_MODULE?.trim();
+  if (explicit && fs.existsSync(explicit)) return explicit;
+
+  for (const distDir of candidateDistDirs()) {
+    const runtimeModule = findRuntimeModuleInDist(distDir);
+    if (runtimeModule) return runtimeModule;
+  }
+
+  const nvmNodeDir = path.join(os.homedir(), '.nvm', 'versions', 'node');
+  if (fs.existsSync(nvmNodeDir)) {
+    for (const entry of fs.readdirSync(nvmNodeDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const distDir = path.join(nvmNodeDir, entry.name, 'lib', 'node_modules', 'openclaw', 'dist');
+      const runtimeModule = findRuntimeModuleInDist(distDir);
+      if (runtimeModule) return runtimeModule;
+    }
+  }
+
+  return '';
+}
+
+function findCompatibleNodeBin(runtimeModulePath) {
+  const explicit = process.env.OPENCLAW_NODE_BIN?.trim();
+  if (explicit && fs.existsSync(explicit)) return explicit;
+
+  const normalized = path.normalize(runtimeModulePath);
+  const unixMarker = `${path.sep}lib${path.sep}node_modules${path.sep}openclaw${path.sep}dist${path.sep}`;
+  const unixIndex = normalized.lastIndexOf(unixMarker);
+  if (unixIndex !== -1) {
+    const prefixDir = normalized.slice(0, unixIndex);
+    const unixNode = path.join(prefixDir, 'bin', 'node');
+    if (fs.existsSync(unixNode)) return unixNode;
+    const winNode = path.join(prefixDir, 'node.exe');
+    if (fs.existsSync(winNode)) return winNode;
+  }
+
+  return process.execPath;
+}
+
+function parseLastJsonObject(raw) {
+  const jsonLine = raw
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith('{') && line.endsWith('}'))
+    .slice(-1)[0];
+  if (!jsonLine) {
+    throw new Error(`OpenClaw smoke script did not emit a JSON payload.\n${raw}`);
+  }
+  return JSON.parse(jsonLine);
+}
+
+function copyRecursive(sourcePath, targetPath) {
+  const stat = fs.statSync(sourcePath);
+  if (stat.isDirectory()) {
+    fs.mkdirSync(targetPath, { recursive: true });
+    for (const entry of fs.readdirSync(sourcePath)) {
+      copyRecursive(path.join(sourcePath, entry), path.join(targetPath, entry));
+    }
+    return;
+  }
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  fs.copyFileSync(sourcePath, targetPath);
+}
+
+function setSafePermissions(targetPath) {
+  if (process.platform === 'win32' || !fs.existsSync(targetPath)) return;
+  const stat = fs.statSync(targetPath);
+  fs.chmodSync(targetPath, stat.isDirectory() ? 0o755 : 0o644);
+  if (stat.isDirectory()) {
+    for (const entry of fs.readdirSync(targetPath)) {
+      setSafePermissions(path.join(targetPath, entry));
+    }
+  }
+}
+
+function stagePluginForSmoke() {
+  const stagedRoot = fs.mkdtempSync(path.join(runtimeTempDir, 'stella-timeline-plugin-smoke-'));
+  for (const entry of ['package.json', 'openclaw.plugin.json', 'dist']) {
+    const sourcePath = path.join(repoRoot, entry);
+    if (!fs.existsSync(sourcePath)) {
+      throw new Error(`OpenClaw smoke staging missing required path: ${sourcePath}`);
+    }
+    copyRecursive(sourcePath, path.join(stagedRoot, entry));
+  }
+  setSafePermissions(stagedRoot);
+  return stagedRoot;
+}
+
+const runtimeModule = findOpenClawRuntimeModule();
+if (!runtimeModule) {
+  console.log('Skipping OpenClaw smoke: OpenClaw runtime not found on this machine.');
+  process.exit(0);
+}
+
+const openClawNodeBin = findCompatibleNodeBin(runtimeModule);
+const stagedPluginRoot = stagePluginForSmoke();
+const script = `
+  import fs from 'node:fs';
+  import { pathToFileURL } from 'node:url';
+
+  const runtimeModulePath = ${JSON.stringify(runtimeModule)};
+  const repoRoot = ${JSON.stringify(repoRoot)};
+  const pluginRoot = ${JSON.stringify(stagedPluginRoot)};
+  const runtimeSource = fs.readFileSync(runtimeModulePath, 'utf8');
+  const alias = (symbolName) => runtimeSource.match(new RegExp('\\\\b' + symbolName + ' as ([\\\\w$]+)'))?.[1] || symbolName;
+  const runtime = await import(pathToFileURL(runtimeModulePath).href);
+  const loadOpenClawPlugins = runtime[alias('loadOpenClawPlugins')]
+    || runtime.loadOpenClawPlugins
+    || runtime.default?.[alias('loadOpenClawPlugins')]
+    || runtime.default?.loadOpenClawPlugins;
+  const resolvePluginTools = runtime[alias('resolvePluginTools')]
+    || runtime.resolvePluginTools
+    || runtime.default?.[alias('resolvePluginTools')]
+    || runtime.default?.resolvePluginTools;
+
+  if (typeof loadOpenClawPlugins !== 'function' || typeof resolvePluginTools !== 'function') {
+    throw new Error('Unable to resolve OpenClaw runtime exports from ' + runtimeModulePath);
+  }
+
+  const config = {
+    plugins: {
+      allow: ['stella-timeline-plugin'],
+      load: { paths: [pluginRoot] },
+      entries: { 'stella-timeline-plugin': { enabled: true } },
+    },
+    tools: {
+      profile: 'coding',
+      alsoAllow: ['stella-timeline-plugin'],
+    },
+  };
+
+  const registry = loadOpenClawPlugins({ config, workspaceDir: repoRoot });
+  const plugin = registry.plugins.find((entry) => entry.id === 'stella-timeline-plugin');
+  const resolvedTools = resolvePluginTools({
+    context: { config, workspaceDir: repoRoot, sandboxed: true },
+    existingToolNames: new Set(),
+    toolAllowlist: ['stella-timeline-plugin'],
+  });
+
+  console.log(JSON.stringify({
+    runtimeModulePath,
+    plugin: plugin ? {
+      status: plugin.status,
+      toolNames: plugin.toolNames,
+    } : null,
+    resolvedToolNames: resolvedTools.map((tool) => tool.name),
+  }));
+`;
+
+const result = spawnSync(openClawNodeBin, ['--input-type=module', '-e', script], {
+  cwd: repoRoot,
+  encoding: 'utf8',
+  env: {
+    ...process.env,
+    TMPDIR: runtimeTempDir,
+    TMP: runtimeTempDir,
+    TEMP: runtimeTempDir,
   },
-);
-
-process.exit(result.status ?? 1);
+});
+
+if (result.status !== 0) {
+  const output = `${result.stdout || ''}${result.stderr || ''}`.trim();
+  console.error(output || `OpenClaw smoke failed with exit code ${result.status}`);
+  process.exit(result.status ?? 1);
+}
+
+const payload = parseLastJsonObject(result.stdout || '');
+if (!payload.plugin) {
+  console.error(`OpenClaw smoke did not load stella-timeline-plugin.\n${result.stdout || ''}`);
+  process.exit(1);
+}
+if (payload.plugin.status !== 'loaded') {
+  console.error(`OpenClaw smoke loaded stella-timeline-plugin with unexpected status: ${payload.plugin.status}`);
+  process.exit(1);
+}
+if (!Array.isArray(payload.resolvedToolNames) || !payload.resolvedToolNames.includes('timeline_resolve')) {
+  console.error(`OpenClaw smoke did not resolve timeline_resolve into runtime tools.\n${JSON.stringify(payload)}`);
+  process.exit(1);
+}
+
+console.log(`OpenClaw smoke passed using ${runtimeModule}`);

package/scripts/setup-openclaw-workspace.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import {
   buildAgentsContract,
@@ -10,11 +11,17 @@ import {
   resolveCanonicalRootPath,
 } from './workspace-contract.mjs';
 
+const PLUGIN_ID = 'stella-timeline-plugin';
+const DEFAULT_OPENCLAW_CONFIG = path.join(os.homedir(), '.openclaw', 'openclaw.json');
+
 function parseArgs(argv) {
   const options = {
     workspace: path.resolve(process.cwd()),
     canonicalRootName: 'memory',
     createMemoryRoot: true,
+    pluginDir: path.resolve(process.cwd()),
+    openclawConfig: DEFAULT_OPENCLAW_CONFIG,
+    skipOpenclawConfig: false,
   };
 
   for (let i = 0; i < argv.length; i += 1) {
@@ -31,6 +38,18 @@ function parseArgs(argv) {
       options.createMemoryRoot = false;
       continue;
     }
+    if (arg === '--plugin-dir') {
+      options.pluginDir = path.resolve(argv[++i] || '');
+      continue;
+    }
+    if (arg === '--openclaw-config') {
+      options.openclawConfig = path.resolve(argv[++i] || '');
+      continue;
+    }
+    if (arg === '--skip-openclaw-config') {
+      options.skipOpenclawConfig = true;
+      continue;
+    }
     if (arg === '--help' || arg === '-h') {
       printHelp();
       process.exit(0);
@@ -43,9 +62,17 @@ function parseArgs(argv) {
 
 function printHelp() {
   console.log([
-    'Usage: openclaw-timeline-setup [--workspace <dir>] [--canonical-root-name <name>] [--no-create-memory-root]',
+    'Usage: openclaw-timeline-setup [options]',
     '',
-    'Idempotently appends the required Timeline contract blocks to AGENTS.md and SOUL.md.',
+    'Idempotently sets up the Timeline plugin: patches AGENTS.md, SOUL.md, and openclaw.json.',
+    '',
+    'Options:',
+    '  --workspace <dir>            Workspace to patch AGENTS.md / SOUL.md (default: cwd)',
+    '  --canonical-root-name <name> Memory root folder name (default: memory)',
+    '  --no-create-memory-root      Skip creating the memory root directory',
+    '  --plugin-dir <dir>           Plugin source directory to register in openclaw.json (default: cwd)',
+    '  --openclaw-config <path>     Path to openclaw.json (default: ~/.openclaw/openclaw.json)',
+    '  --skip-openclaw-config       Skip patching openclaw.json',
   ].join('\n'));
 }
 
@@ -75,6 +102,47 @@ function writeFile(filePath, content) {
   fs.writeFileSync(filePath, content, 'utf8');
 }
 
+function mergeUniqueArray(existing, value) {
+  if (!Array.isArray(existing)) return [value];
+  return existing.includes(value) ? existing : [...existing, value];
+}
+
+function patchOpenclawConfig(configPath, pluginDir) {
+  if (!fs.existsSync(configPath)) {
+    return { changed: false, skipped: true, reason: `${configPath} not found` };
+  }
+
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch {
+    return { changed: false, skipped: true, reason: `${configPath} is not valid JSON` };
+  }
+
+  const original = JSON.stringify(config);
+
+  // plugins.allow
+  config.plugins = config.plugins || {};
+  config.plugins.allow = mergeUniqueArray(config.plugins.allow, PLUGIN_ID);
+
+  // plugins.load.paths
+  config.plugins.load = config.plugins.load || {};
+  config.plugins.load.paths = mergeUniqueArray(config.plugins.load.paths, pluginDir);
+
+  // plugins.entries.<id>.enabled
+  config.plugins.entries = config.plugins.entries || {};
+  config.plugins.entries[PLUGIN_ID] = config.plugins.entries[PLUGIN_ID] || {};
+  config.plugins.entries[PLUGIN_ID].enabled = true;
+
+  const updated = JSON.stringify(config);
+  if (original === updated) {
+    return { changed: false, skipped: false };
+  }
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+  return { changed: true, skipped: false };
+}
+
 function main() {
   const options = parseArgs(process.argv.slice(2));
   const agentsPath = path.join(options.workspace, 'AGENTS.md');
@@ -108,6 +176,15 @@ function main() {
     `${options.createMemoryRoot ? 'ensured' : 'skipped'} ${canonicalRootPath}`,
   ];
 
+  if (!options.skipOpenclawConfig) {
+    const configResult = patchOpenclawConfig(options.openclawConfig, options.pluginDir);
+    if (configResult.skipped) {
+      updates.push(`skipped ${options.openclawConfig} (${configResult.reason})`);
+    } else {
+      updates.push(`${configResult.changed ? 'updated' : 'kept'} ${options.openclawConfig}`);
+    }
+  }
+
   console.log(updates.join('\n'));
 }
 

package/skills/timeline/SKILL.md

@@ -1,111 +1,111 @@
----
-name: timeline
-description: 当问题在询问当前状态、过去某个具体时间点、过去一段时间，或下游技能需要时间状态事实时，先进入 timeline skill，再把原始自然语言 query 交给 Timeline；禁止只根据人设直接回答。
----
-
-# Timeline
-
-遇到和时间状态或回忆有关的请求时，先调用 Timeline，再组织回答。不要先按人设猜，也不要先直接读 `memory/` 自己下结论。
-
-## 这个 skill 负责什么
-
-这个 skill 只负责两件事：
-
-1. 判断这次请求是否属于 Timeline 应接管的时间现实问题。
-2. 把用户原话或下游技能的自然语言问题，原样交给 `timeline_resolve`。
-
-它不直接生成事实，也不负责自己归一化时间，更不负责绕过 Timeline 直接回答。
-当目标时间缺少既有事实时，生成与写入的决定交给 Timeline 内部处理。
-
-## 强制规则
-
-1. 涉及时间现实的问题，先调用 `timeline_resolve`，后回答。
-2. 不要只根据 `SOUL.md`、`IDENTITY.md`、`MEMORY.md` 直接回答“现在在做什么”或“最近发生了什么”。
-3. `SOUL` / `IDENTITY` / `MEMORY` 只用于帮助理解和表述，不能替代 Timeline 事实。
-4. 不要在调用前自行把 query 改写成结构化时间参数。
-5. 时间分类与时间归一化统一交给 Timeline 内部处理。
-6. `timeline_resolve` 返回既有事实时，优先复用；不要改写它。
-7. 如果用户是普通闲聊而不是严格只读校验，允许 Timeline 生成缺失事实并写入 canon。
-
-## 调用格式
-
-默认主路径：
-
-```json
-{
-  "query": "用户的原话"
-}
-```
-
-不要向 `timeline_resolve` 传时间点、时间范围、请求类型、模式或调试字段。它的公开入口就是自然语言 query。
-
-## 场景拆分
-
-### 场景 A：当前状态
-
-抽象描述：
-
-- 用户在问“此刻”或“当前这一小段时间”的状态。
-- 目标是回答现在在哪里、在做什么、是什么状态。
-
-示例：
-
-- “你在干嘛”
-- “你现在在哪”
-- “你现在什么状态”
-- “你刚才不是在打球吗，现在还在吗”
-- 下游技能要取当前状态，例如自拍、场景描述、状态卡片
-
-处理方式：
-
-- 调 `timeline_resolve`
-- `query` 就是用户原话
-- 不要自己先判断它是不是 `now`
-
-### 场景 B：过去某个具体时间点
-
-抽象描述：
-
-- 用户在问某个足够明确的时间点。
-- 目标是围绕明确时间锚点回忆事实。
-
-示例：
-
-- “昨晚八点你在做什么”
-- “你昨天上午十点在哪”
-- “你昨晚八点是不是还在看电视”
-- “上周六晚上九点你在忙什么”
-
-处理方式：
-
-- 调 `timeline_resolve`
-- `query` 就是用户原话
-- 不要自己把时间点归一化后再传
-
-### 场景 C：过去一段时间
-
-抽象描述：
-
-- 用户在问一个时间段内的整体情况，而不是某个点。
-- 目标是组织一段时间里的回忆、活动概览或最近动态。
-
-示例：
-
-- “最近有什么有趣的事吗”
-- “你最近都在忙什么”
-- “这几天怎么样”
-- “你今天都忙了什么”
-- “昨晚在做什么”
-
-处理方式：
-
-- 调 `timeline_resolve`
-- `query` 就是用户原话
-- “最近”“昨晚”“今天都”这类自然语言范围，统一交给 Timeline 内部 planner 理解
-
-## 回答要求
-
-- 对用户说人话，不要提 `timeline_resolve`。
-- 语气自然，像真人在回忆或描述当下。
-- 如果 Timeline 返回的是空窗口或失败，不要假装已有确定事实；按可用结果谨慎表达。
-- 除非用户明确要求看原始结果，否则不要输出 JSON。
+---
+name: timeline
+description: When a request asks about the current state, a specific past time, a past range, or a downstream skill needs time-state facts, enter the timeline skill first and pass the raw natural-language query to Timeline. Never answer from persona alone.
+---
+
+# Timeline
+
+When a request is about time-state facts or recall, call Timeline first and then compose the reply. Do not guess from persona first, and do not read `memory/` directly and make your own conclusion.
+
+## Scope
+
+This skill does only two things:
+
+1. Decide whether the request is a time-grounded reality question that Timeline should own.
+2. Pass the user's exact wording, or the downstream skill's natural-language question, straight into `timeline_resolve`.
+
+It does not generate facts directly, normalize time on its own, or bypass Timeline and answer directly.
+When the target time lacks an existing fact, Timeline decides whether to generate and write.
+
+## Hard Rules
+
+1. For time-reality questions, call `timeline_resolve` first and answer second.
+2. Do not answer "what are you doing now" or "what happened recently" from `SOUL.md`, `IDENTITY.md`, or `MEMORY.md` alone.
+3. `SOUL` / `IDENTITY` / `MEMORY` help with interpretation and phrasing, but they cannot replace Timeline facts.
+4. Do not rewrite the query into structured time parameters before the call.
+5. Let Timeline own time classification and time normalization.
+6. If `timeline_resolve` returns an existing fact, reuse it as-is.
+7. If the user is doing ordinary conversation rather than strict read-only verification, Timeline may generate missing facts and write canon.
+
+## Call Shape
+
+Default path:
+
+```json
+{
+  "query": "the user's exact words"
+}
+```
+
+Do not pass time points, time ranges, request types, modes, or debug fields into `timeline_resolve`. Its public interface is the natural-language query.
+
+## Scenarios
+
+### Scenario A: Current State
+
+Abstract shape:
+
+- The user is asking about "right now" or the current short stretch of time.
+- The goal is to answer where she is, what she is doing, or what state she is in.
+
+Examples:
+
+- “你在干嘛”
+- “你现在在哪”
+- “你现在什么状态”
+- “你刚才不是在打球吗，现在还在吗”
+- A downstream skill needs the current state, such as a selfie, scene description, or status card
+
+Handling:
+
+- Call `timeline_resolve`
+- Set `query` to the user's exact wording
+- Do not decide `now` yourself before calling
+
+### Scenario B: A Specific Past Time
+
+Abstract shape:
+
+- The user is asking about a sufficiently specific point in time.
+- The goal is to recall facts around that time anchor.
+
+Examples:
+
+- “昨晚八点你在做什么”
+- “你昨天上午十点在哪”
+- “你昨晚八点是不是还在看电视”
+- “上周六晚上九点你在忙什么”
+
+Handling:
+
+- Call `timeline_resolve`
+- Set `query` to the user's exact wording
+- Do not normalize the time point yourself before passing it through
+
+### Scenario C: A Past Range
+
+Abstract shape:
+
+- The user is asking about the overall state of a time range rather than a single point.
+- The goal is to organize recall, an activity overview, or recent updates from that range.
+
+Examples:
+
+- “最近有什么有趣的事吗”
+- “你最近都在忙什么”
+- “这几天怎么样”
+- “你今天都忙了什么”
+- “昨晚在做什么”
+
+Handling:
+
+- Call `timeline_resolve`
+- Set `query` to the user's exact wording
+- Let Timeline's internal planner interpret natural-language ranges such as “最近”, “昨晚”, or “今天都”
+
+## Reply Requirements
+
+- Speak naturally to the user and do not mention `timeline_resolve`.
+- Keep the tone human, like natural recall or present-moment description.
+- If Timeline returns an empty window or a failure, do not pretend you have certain facts; phrase the answer cautiously from what is available.
+- Do not output JSON unless the user explicitly asks for raw results.