mio-agent-runtime 0.13.1 → 0.13.3

package/README.md

@@ -40,7 +40,7 @@ mio evolution authority plan      Preview a gated authority switch plan (--readi
 mio evolution migration plan      Preview state migration diffs (--legacy-records/--modular-records JSON; required)
 mio evolution cutover apply --dry-run   Dry-run a cutover plan (--plan JSON and --dry-run are both required)
 mio observe                 Watch WorkBuddy transcripts and auto-ingest task outcomes (foreground)
-mio observe --start|--stop|--status|--once   Manage the background observer daemon
+mio observe --start [--research]|--stop|--status|--once   Manage the background observer daemon (--research also starts the research scheduler)
 mio recall "<query>"        Search Mio memory from the terminal (--project/--scope/--kind/--tags/--limit)
 mio traces                  Show recent observer traces (--type/--outcome/--agent/--since/--limit/--compact)
 mio prune --days 30         Trim old traces/queries/reuse records and observe.log (--dry-run to preview; --memory needs --yes)
@@ -66,6 +66,7 @@ mio observer <view>          Observer research pipeline views (research pipeline
 mio observer collect         Fetch from the configured sources (--sources a,b/--keywords k1,k2/--limit N)
 mio observer ferment         Run the fermentation engine (--session morning|afternoon|night)
 mio observer pipeline        Run the research DAG (previews by default; --run executes, --mode neutral|analytical|creative)
+mio observer serve           Keep the research scheduler running (previews with --dry-run; Ctrl+C stops it)
 mio observer ingest --trace-id T --event-type E   Record a trace event (--payload JSON/--outcome)
 mio observer subscribe --event-types a,b          Subscribe to events (--yes to apply; previews by default)
 mio observer digest                               New events since the last digest (advances the cursor)
@@ -132,7 +133,7 @@ MCP 服务端在 5 大域共暴露 50 个工具：
 | `@akemi-mio/evolution-strategy` | 演化策略引擎 |
 | `@akemi-mio/evolution-safety` | 安全护栏 |
 | `@akemi-mio/evolution-scheduler` | 演化调度器 |
-| `@akemi-mio/observer` | ObserverService —— 多源数据采集、趋势分析、深度研究、世界模型、发酵、DAG 状态机、自演化引擎（零 npm 依赖） |
+| `@akemi-mio/observer` | ObserverService —— 多源数据采集、趋势分析、深度研究、世界模型、发酵、DAG 状态机、自演化引擎（唯一运行时依赖 `undici`，只用于走代理采集） |
 | `@akemi-mio/insight` | InsightService —— 基于 LLM 的洞察生成、冲突/漂移/重复/停滞目标/摩擦检测器、在场服务、洞察打分（零 npm 依赖） |
 
 以下 `@akemi-mio` 包同样位于本 monorepo 中并独立发布，但**不是**本 CLI 的依赖——其源码从不 import 它们，因此未声明在 `package.json` 里：
@@ -499,6 +500,26 @@ mio observer trends --base-dir /path/to/.local/observer
   mio observer pipeline --mode creative --run
   ```
 
+- **`mio observer serve` 让"日更引擎"真正自动跑起来**（D6）。`ObserverService.start()` 早就配好了各源的采集间隔、60 秒一次的管道 tick 与 5 秒后的首次 tick，并在"今天的 DAG 已 `COMPLETED`"时跳过——但 runtime 里**没有任何长驻进程调用过它**，这些闸门一次都没生效过，trends / research / insights 只有手动 `mio observer pipeline --run` 才会出现。现在有了宿主：
+
+  ```bash
+  mio observer serve              # 前台常驻：采集 + 每日一次完整 DAG（Ctrl+C 停）
+  mio observer serve --dry-run    # 只打印计划：baseDir / LLM / tick 周期 / 锁文件
+  mio observe --start --research  # 顺带把调度器作为第二个受 pid 管理的子进程拉起
+  ```
+
+  - `--dry-run` 不构造服务、不建目录、不联网，因此也是文档门禁实跑的参数（`SAFE_ARGS['observer:serve']`）。
+  - `--research` 是**显式开关**：默认 `mio observe --start` 只启动转写观察守护，不会悄悄开始花 LLM 调用。研究子进程日志写到 `<MIO_HOME>/research.log`（用 append fd 而不是管道：没人读的管道写满 64KB 就会把调度器卡死），`mio observe --status --json` 给出它的 pid 与日志路径，`mio observe --stop` 一并停掉两者。
+  - 研究数据仍落在**启动它的那个工作目录**的 `<cwd>/.local/observer`（与 `mio observer status` 一致）：子进程显式收到 `--base-dir`，因为转写守护 spawn 时 cwd 被钉成 `MIO_HOME`，若在守护进程里直接起调度，会多出一套谁也读不到的观察目录。
+  - 刻意**不提供** `mio.observer.serve` 这类 MCP 工具：每个连上的 MCP server 都会各起一个调度器，客户端一重启就多一个。
+  - `ObserverService` 内的 `pipelineRunning` 只防同进程并发；serve 子进程、守护与手动 `--run` 是三个进程，所以 `runPipeline` 现在还要抢 `<baseDir>/dag/pipeline.lock`（`O_EXCL` 建文件 + pid / mtime TTL，持有者已死即可接管）。锁被占时直接返回 `null`，不排队。
+
+- **采集会走系统与环境里配置的代理**（D7）。6 个采集源共 9 处请求此前直接用全局 `fetch`，而 Node 的 fetch **不读任何代理配置**——所以浏览器能打开的页面，采集全部超时（issue #3：Windows 开着系统代理、直连不通时，weibo / rss / hackernews / douyin / bilibili / github-trending 全军覆没）。现在统一走 `@akemi-mio/observer` 的 `httpFetch()`：
+  - 代理按顺序取：`HTTPS_PROXY` / `HTTP_PROXY` / `ALL_PROXY`（大小写皆可）→ Windows 系统代理（`reg query` 读 HKCU Internet Settings 的 `ProxyEnable` / `ProxyServer` / `ProxyOverride`，进程内缓存 30 秒）。`ProxyServer` 的 `h=..;https=..` 与单值两种写法都认，**端口读实时注册表**——issue 里写的 7990 早已不是本机端口，硬编码必然过期。
+  - 绕过：`NO_PROXY` 与 `ProxyOverride`，支持 `*`、`<local>`、`*.zhihu.com`、`127.*`、裸域名（含子域）。
+  - **解析不到代理就走原生 `fetch`，与从前逐字节一致**；解析到代理时用 `undici` 的 `ProxyAgent`（CONNECT 隧道，https 与 http 目标同样处理）。代理连不上（`ECONNREFUSED` / `ENOTFOUND` / `EHOSTUNREACH`）会**回退直连**并记 `proxy_fallback_direct`，避免"系统代理开着但客户端已关"把原本能通的直连也搞坏。
+  - `ObserverLlmService` 不在这条通路上（issue 只讲采集失败）。
+
 - **观察者的 LLM 现在与 creativity / insight 共用同一份配置**。此前 `ObserverLlmService` 把 Ollama 地址与模型写死（`localhost:11434` / `qwen2.5:7b`，只认 `OBSERVER_*` 环境变量），完全无视 `mio config llm` —— 于是 `mio config llm` 配好的 deepseek 只对 server 侧生效，观察管道仍然空转。现在 `observer-store.js` 通过共享的 `server/llm-client.js` 解析配置并注入：用户配置过（`config.json` 的 `llm` 或 `LLM_*` 环境变量）就用它，否则保持 `@akemi-mio/observer` 自己的 `LLM_*` / `OBSERVER_*` / 本地 Ollama 回退，不会把既有本地 Ollama 用户静默改道到托管默认值。端点按 URL 形态自动选择传输：含 `/chat/completions` 走 OpenAI 兼容协议，否则按 Ollama 处理。
 - **`mio observer ingest` 记录任意 trace 事件**（`tool_call` / `error` / `retry` / `task_outcome`）：
 

package/bin/mio.js

@@ -27,7 +27,7 @@ const { CreativityEngine } = require('../server/creativity-engine.js')
 const { createAgentStore } = require('../server/agent-store.js')
 const { createEvaluationStore } = require('../server/evaluation-store.js')
 const { createInsightStore } = require('../server/insight-store.js')
-const { createObserverStore } = require('../server/observer-store.js')
+const { createObserverStore, isObserverAvailable } = require('../server/observer-store.js')
 const { loadPhase0, renderPhase0Markdown } = require('../server/mio-intelligence-mcp/phase0.js')
 const { listHostCapabilities } = require('../server/host-capabilities.js')
 const { createTaskStore } = require('../server/task-store.js')
@@ -1533,6 +1533,10 @@ function observerUsage(write = console.log) {
   mio observer pipeline      Run the full research DAG (collect → trend → research →
                              insights → world model). Previews by default; --run
                              executes it (network + LLM). --mode neutral|analytical|creative
+  mio observer serve         Keep the research scheduler running in this terminal:
+                             collectors on their intervals + one pipeline run per
+                             day. Previews with --dry-run (that is what runs it
+                             the README/doc gate); Ctrl+C stops it.
 
 Options:
   --base-dir DIR     Observer data directory (default: <cwd>/.local/observer)
@@ -1884,6 +1888,9 @@ function printObserverPipeline(result) {
   }
   if (!result.completed) {
     console.log(`Observer pipeline did not complete: ${result.reason || 'unknown reason'}`)
+    // Show what the run actually produced, so a failing exit code is diagnosable
+    // instead of a bare "unknown reason".
+    console.log(`  sections=${result.sections || 0} topic=${result.topic || 'none'} insight=${result.insightId || 'none'}`)
     process.exitCode = 1
     return
   }
@@ -1915,6 +1922,66 @@ async function observerPipelineCommand(args, useJson) {
   printObserverPipeline(result)
 }
 
+function printObserverServe(result) {
+  if (result.dryRun) {
+    console.log(`Observer research scheduler preview (base-dir=${result.baseDir})`)
+    if (result.llm) {
+      const key = result.llm.hasApiKey ? 'key set' : 'no key'
+      console.log(`  LLM: ${result.llm.provider} ${result.llm.model} (${key})`)
+      console.log(`       ${result.llm.apiUrl}`)
+    } else {
+      console.log('  LLM: unknown (observer package did not expose ObserverLlmService)')
+    }
+    if (result.schedule) {
+      console.log(`  pipeline: first tick ${result.schedule.pipelineFirstTickMs}ms, then every ${result.schedule.pipelineTickMs}ms`)
+      console.log(`  gate: ${result.schedule.pipelineGate}`)
+      console.log(`  lock: ${result.schedule.lockFile}`)
+    }
+    console.log('\nPreview only. Re-run without --dry-run to keep the scheduler running (Ctrl+C stops it).')
+    return
+  }
+  console.log(`Observer research scheduler running (base-dir=${result.baseDir})`)
+  console.log(`  ${result.schedule ? result.schedule.collectors : 'collectors started'}`)
+  console.log(`  pipeline: first tick ${result.schedule ? result.schedule.pipelineFirstTickMs : 5000}ms, then every ${result.schedule ? result.schedule.pipelineTickMs : 60000}ms`)
+  console.log('  Stops with Ctrl+C (or `mio observe --stop` when started that way).')
+}
+
+// D6: `mio observer serve` is the long-lived host for ObserverService.start().
+// Without it the scheduler inside the service had no caller, so tickPipeline's
+// daily gate never fired and trends/research/insights only appeared if someone
+// ran `mio observer pipeline --run` by hand. It stays in the foreground on
+// purpose -- a scheduler is a process, not a request -- and `--dry-run` exists
+// both as a preview and as the probe `check:cli-docs` runs, so the documented
+// command can never hang the gate.
+async function observerServeCommand(args, useJson) {
+  const flags = args.slice(2)
+  const base = { baseDir: optionValue(flags, '--base-dir') }
+  const dryRun = flagPresent(flags, '--dry-run')
+  let result
+  try {
+    result = await cliObserverStore().serve({ ...base, dryRun })
+  } catch (error) {
+    console.error(error.message || error)
+    process.exitCode = 1
+    return
+  }
+  if (useJson && result.dryRun) return jsonOrText(result, true)
+  if (result.dryRun) {
+    printObserverServe(result)
+    return
+  }
+  if (useJson) console.log(JSON.stringify({ serving: true, baseDir: result.baseDir, schedule: result.schedule }))
+  else printObserverServe(result)
+  const stop = typeof result.stop === 'function' ? result.stop : () => {}
+  const shutdown = (signal) => {
+    stop()
+    console.log('Observer research scheduler stopped (' + signal + ')')
+    process.exit(0)
+  }
+  process.once('SIGINT', () => shutdown('SIGINT'))
+  process.once('SIGTERM', () => shutdown('SIGTERM'))
+}
+
 function observerCommand(args, useJson) {
   const sub = args[1]
   if (!sub || sub === 'help' || sub === '--help' || sub === '-h') {
@@ -1930,6 +1997,7 @@ function observerCommand(args, useJson) {
   if (sub === 'collect') return observerCollectCommand(args, useJson)
   if (sub === 'ferment') return observerFermentCommand(args, useJson)
   if (sub === 'pipeline') return observerPipelineCommand(args, useJson)
+  if (sub === 'serve') return observerServeCommand(args, useJson)
 
   if (!['status', 'world-model', 'trends', 'research', 'insights', 'essays', 'dag'].includes(sub)) {
     console.error(`Unknown observer subcommand: ${sub}`)
@@ -3095,26 +3163,67 @@ function mcpCommand() {
   require(SERVER_SCRIPT)
 }
 
-function observeCommand(args) {
+// `--research` is opt-in: it adds a second child (mio observer serve) that owns
+// the collector intervals and the daily pipeline tick. It is deliberately not
+// on by default -- starting the transcript watcher should not silently start
+// spending LLM calls in the background (D6).
+function startResearchScheduler(cwd) {
+  if (!isObserverAvailable()) {
+    return { running: false, started: false, pid: null, skipped: '@akemi-mio/observer not installed' }
+  }
+  return observer.startResearchBackground(MIO_HOME, { cwd })
+}
+
+function observeCommand(args, jsonFlag = false) {
   const flags = args.slice(1)
-  const useJson = flags.includes('--json')
+  // main() already strips --json from argv and passes it as the second
+  // argument; the local check is kept for direct callers. Without the
+  // parameter `mio observe --json --status` silently printed text.
+  const useJson = jsonFlag || flags.includes('--json')
+  const research = flags.includes('--research')
   if (flags.includes('--start')) {
     const result = observer.startBackground(MIO_HOME)
-    if (useJson) return jsonOrText(result, true)
+    const researchResult = research ? startResearchScheduler(process.cwd()) : null
+    if (useJson) {
+      return jsonOrText({ ...result, research: researchResult || { running: null, started: false, pid: null } }, true)
+    }
     console.log(result.started ? 'Observer started.' : 'Observer already running.')
+    if (researchResult) {
+      if (researchResult.skipped) console.log('Research scheduler skipped: ' + researchResult.skipped)
+      else if (researchResult.started) console.log('Research scheduler started (pid ' + researchResult.pid + ', base-dir ' + researchResult.baseDir + ')')
+      else console.log('Research scheduler already running (pid ' + researchResult.pid + ')')
+    }
     return
   }
   if (flags.includes('--stop')) {
     const result = observer.stopBackground(MIO_HOME)
-    if (useJson) return jsonOrText(result, true)
+    const researchResult = observer.stopResearchBackground(MIO_HOME)
+    if (useJson) {
+      return jsonOrText(
+        { ...result, research: { running: false, stopped: researchResult.stopped, pid: researchResult.pid } },
+        true
+      )
+    }
     console.log(result.stopped ? 'Observer stopped.' : 'Observer was not running.')
+    console.log(researchResult.stopped ? 'Research scheduler stopped.' : 'Research scheduler was not running.')
     return
   }
   if (flags.includes('--status')) {
     const running = observer.isRunning(MIO_HOME)
     const pid = observer.readPid(MIO_HOME)
-    if (useJson) return jsonOrText({ running, pid }, true)
+    const researchRunning = observer.isResearchRunning(MIO_HOME)
+    const researchPid = observer.readResearchPid(MIO_HOME)
+    const researchInfo = { running: researchRunning, pid: researchPid, logFile: observer.researchLogFile(MIO_HOME) }
+    if (useJson) return jsonOrText({ running, pid, research: researchInfo }, true)
     console.log(running ? 'Observer: running (pid ' + pid + ')' : 'Observer: not running')
+    console.log(
+      researchRunning ? 'Research scheduler: running (pid ' + researchPid + ')' : 'Research scheduler: not running'
+    )
+    return
+  }
+  if (flags.includes('--research') && !flags.includes('--start')) {
+    console.error('--research only applies to --start; run `mio observer serve` to run the scheduler in this terminal.')
+    process.exitCode = 1
     return
   }
   if (flags.includes('--once')) {
@@ -3165,7 +3274,7 @@ Usage:
   mio evolution migration plan      Preview state migration diffs (--legacy-records/--modular-records JSON; required)
   mio evolution cutover apply --dry-run   Dry-run a cutover plan (--plan JSON and --dry-run are both required)
   mio observe                 Watch WorkBuddy transcripts and auto-ingest task outcomes
-  mio observe --start|--stop|--status|--once   Manage the background observer daemon
+  mio observe --start [--research]|--stop|--status|--once   Manage the background observer daemon
   mio recall "<query>"        Search Mio memory from the terminal (same ranking as mio.memory.query)
   mio traces                  Show recent observer traces (--type/--outcome/--agent/--since/--limit/--compact)
   mio remember "<content>"    Write a memory record from the terminal (same schema as mio.memory.record)
@@ -3194,6 +3303,7 @@ Usage:
   mio observer collect         Fetch from the configured sources (--sources/--keywords/--limit)
   mio observer ferment         Run the fermentation engine (--session morning|afternoon|night)
   mio observer pipeline        Run the research DAG (previews; --run to execute, --mode neutral|analytical|creative)
+  mio observer serve           Keep the research scheduler running (previews with --dry-run; Ctrl+C stops it)
   mio phase0 report            Show the Phase 0 validation report (--project X, --format markdown)
   mio host capabilities        Show what each host supports and whether it is installed
   mio task route "<task>"      Which verified experiences apply to this task (--project/--scope/--limit)
@@ -3229,7 +3339,7 @@ async function main() {
     case 'agents':
       return agentsCommand(args, useJson)
     case 'observe':
-      return observeCommand(args)
+      return observeCommand(args, useJson)
     case 'recall':
       return recallCommand(args, useJson)
     case 'traces':

package/observe/observer.js

@@ -1695,9 +1695,35 @@ function pidFile(home) {
   return path.join(home, 'observe.pid')
 }
 
+function researchPidFile(home) {
+  return path.join(home, 'research.pid')
+}
+
+function researchLogFile(home) {
+  return path.join(home, 'research.log')
+}
+
+function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (_) {
+    return false
+  }
+}
+
 function readPid(home) {
+  return readPidFile(pidFile(home))
+}
+
+function readResearchPid(home) {
+  return readPidFile(researchPidFile(home))
+}
+
+function readPidFile(file) {
   try {
-    const pid = Number(fs.readFileSync(pidFile(home), 'utf8').trim())
+    const pid = Number(fs.readFileSync(file, 'utf8').trim())
     return Number.isInteger(pid) && pid > 0 ? pid : null
   } catch (_) {
     return null
@@ -1705,14 +1731,11 @@ function readPid(home) {
 }
 
 function isRunning(home) {
-  const pid = readPid(home)
-  if (!pid) return false
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch (_) {
-    return false
-  }
+  return pidAlive(readPid(home))
+}
+
+function isResearchRunning(home) {
+  return pidAlive(readResearchPid(home))
 }
 
 function startBackground(home) {
@@ -1745,6 +1768,69 @@ function stopBackground(home) {
   return { running: false, stopped: Boolean(pid), pid: pid || null }
 }
 
+// ---------------------------------------------------------------------------
+// research scheduler daemon (`mio observe --start --research`)
+//
+// D6: ObserverService's own scheduler (collector intervals + the daily
+// pipeline tick) needed a process to live in. The transcript daemon could have
+// hosted it in-process, but that daemon is spawned with cwd: home, so its
+// `<cwd>/.local/observer` would resolve to MIO_HOME -- a second observation
+// directory that `mio observer status` in the project would never see. Running
+// `mio observer serve` as its own child with the *launcher's* cwd keeps one
+// data directory per working directory, exactly like every other observer
+// command, and keeps a crash in either half from taking down the other.
+//
+// spawn/kill are injectable so tests never signal a real pid.
+// ---------------------------------------------------------------------------
+
+function startResearchBackground(home, opts = {}) {
+  const cwd = opts.cwd || process.cwd()
+  const spawnImpl = opts.spawn || spawn
+  if (isResearchRunning(home)) {
+    return { running: true, started: false, pid: readResearchPid(home), baseDir: path.join(cwd, '.local', 'observer') }
+  }
+  const script = path.join(__dirname, '..', 'bin', 'mio.js')
+  const baseDir = path.join(cwd, '.local', 'observer')
+  // The scheduler logs to stdout, so a detached child with stdio:'ignore' would
+  // be undiagnosable ("is it running? did it collect?"). Handing it an append
+  // fd instead of a pipe is deliberate: a pipe nobody reads fills up after
+  // ~64KB and the scheduler would block on its own log.
+  fs.mkdirSync(home, { recursive: true })
+  const logFd = fs.openSync(researchLogFile(home), 'a')
+  let child
+  try {
+    child = spawnImpl(
+      process.execPath,
+      [script, 'observer', 'serve', '--base-dir', baseDir],
+      {
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+        windowsHide: true,
+        cwd,
+      }
+    )
+  } finally {
+    fs.closeSync(logFd)
+  }
+  if (child.unref) child.unref()
+  fs.writeFileSync(researchPidFile(home), String(child.pid), 'utf8')
+  return { running: true, started: true, pid: child.pid, baseDir, logFile: researchLogFile(home) }
+}
+
+function stopResearchBackground(home, killImpl) {
+  const kill = killImpl || process.kill
+  const pid = readResearchPid(home)
+  if (pid) {
+    try {
+      kill(pid)
+    } catch (_) {}
+    try {
+      fs.unlinkSync(researchPidFile(home))
+    } catch (_) {}
+  }
+  return { running: false, stopped: Boolean(pid), pid: pid || null }
+}
+
 module.exports = {
   INTERVAL_MS,
   homeDir,
@@ -1770,6 +1856,11 @@ module.exports = {
   stopBackground,
   isRunning,
   readPid,
+  startResearchBackground,
+  stopResearchBackground,
+  isResearchRunning,
+  readResearchPid,
+  researchLogFile,
   // exported for tests: the numeric-segment guard here was silently dead for
   // several releases because nothing exercised it (see __tests__/observer-project.test.js)
   projectFromDirName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.13.1",
+  "version": "0.13.3",
   "description": "Mio Agent Runtime installer and MCP intelligence layer",
   "license": "MIT",
   "type": "commonjs",
@@ -33,7 +33,7 @@
     "@akemi-mio/evolution-strategy": "^0.1.0",
     "@akemi-mio/evolution-safety": "^0.1.0",
     "@akemi-mio/evolution-scheduler": "^0.1.0",
-    "@akemi-mio/observer": "^0.1.1",
+    "@akemi-mio/observer": "^0.1.3",
     "@akemi-mio/insight": "^0.1.0"
   },
   "main": "index.js",

package/server/observer-store.js

@@ -306,12 +306,22 @@ function createObserverStore(options = {}) {
       }
     }
     const payload = envelope.payload || {}
+    // dagState.state is COMPLETED on @akemi-mio/observer >= 0.1.2, which marks the
+    // dag COMPLETED *before* publishInsight snapshots it into the envelope.
+    // Older producers published while the dag still said STORED even though the
+    // run had in fact finished, and a strict COMPLETED check turned every success
+    // into completed:false (D5). This branch only exists when publishing
+    // succeeded, so STORED counts as completed; anything else is a real failure
+    // and must carry a reason, otherwise the CLI can only print "unknown reason".
+    const state = envelope.dagState ? envelope.dagState.state : null
+    const completed = state === 'COMPLETED' || state === 'STORED'
     return {
       dryRun: false,
       baseDir,
       mode,
       ran: true,
-      completed: envelope.dagState && envelope.dagState.state === 'COMPLETED',
+      completed,
+      ...(completed ? {} : { reason: `unexpected dag state: ${state || 'missing'} (expected COMPLETED)` }),
       type: envelope.type,
       taskId: envelope.dagState ? envelope.dagState.taskId : null,
       topic: payload.topic || null,
@@ -322,6 +332,64 @@ function createObserverStore(options = {}) {
     }
   }
 
+  // D6: the scheduler host. ObserverService.start() wires the per-collector
+  // intervals, a 60s pipeline tick and a 5s first tick, and tickPipeline skips
+  // while today's DAG is COMPLETED -- i.e. the daily research engine already
+  // existed, it just had no long-lived caller anywhere in mio-agent-runtime.
+  // This is that caller.
+  //
+  // Deliberately NOT exposed as an MCP tool: every MCP server that connects
+  // would start its own scheduler against the same dag file, and a client
+  // restart would leave a second one running. The cross-process PipelineLock
+  // keeps runs from interleaving, but a scheduler is a process-lifetime
+  // concern, so it belongs to `mio observer serve` and `mio observe --research`
+  // (both single pid-managed processes), not to a tool call.
+  //
+  // Like `pipeline`, the dry run never constructs the service: the constructor
+  // mkdir's the dag directory and start() begins fetching, and this path is
+  // what `check:cli-docs` runs.
+  async function serve(args = {}) {
+    if (!ObserverService) throw new Error('@akemi-mio/observer not installed')
+    const baseDir = baseDirOf(args)
+    const llmConfig = observerLlmConfig()
+    const schedule = {
+      collectors: 'every source collects on start, then on its own interval (30m weibo / 1h rss,hn,douyin,bilibili / 4h github-trending)',
+      pipelineTickMs: 60000,
+      pipelineFirstTickMs: 5000,
+      pipelineGate: "runs while today's DAG is not COMPLETED -- one full run per day, retried until it completes",
+      lockFile: path.join(baseDir, 'dag', 'pipeline.lock'),
+    }
+    let llm = null
+    if (ObserverLlmService) {
+      try {
+        const svc = new ObserverLlmService(llmConfig)
+        if (svc && typeof svc.getInfo === 'function') llm = svc.getInfo()
+      } catch (_) {
+        llm = null
+      }
+    }
+    if (args.dryRun) {
+      return {
+        dryRun: true,
+        baseDir,
+        observerAvailable: true,
+        llm,
+        schedule,
+        hint: 'Re-run without --dry-run to keep the scheduler in the foreground (Ctrl+C stops it).',
+      }
+    }
+    const service = new ObserverService(baseDir, llmConfig)
+    await service.start()
+    return {
+      dryRun: false,
+      serving: true,
+      baseDir,
+      llm,
+      schedule,
+      stop: () => service.stop(),
+    }
+  }
+
   return {
     baseDir: defaultBaseDir,
     status,
@@ -334,6 +402,7 @@ function createObserverStore(options = {}) {
     collect,
     ferment,
     pipeline,
+    serve,
   }
 }