dsh-deepmoyu 2.3.0 → 2.4.2

package/vendor/bilibili-mcp/runtime_guard.py

@@ -286,7 +286,27 @@ class RuntimeGuard:
             return
         now, factor = self._clock(), self._pace_factor()
 
-        def event(kind, stamp, next_stamp=None):
+        # JS pins the actual next free time into last[kind].next using the factor that
+        # was active when that send happened. Re-deriving it from `recent` with the
+        # *current* factor made "switch to careful" lengthen waits that were already
+        # fixed (observed: 115s became 355s). Keep the recorded value authoritative.
+        last = raw.get("last")
+        stored = []
+        for kind, row in (last.items() if isinstance(last, dict) else []):
+            if isinstance(row, dict):
+                at = _finite(row.get("at"))
+                nxt = _finite(row.get("next"))
+                stored.append((kind, at, nxt if nxt > 0 else None))
+            else:
+                stored.append((kind, _finite(row), None))
+
+        def recorded_next(kind, at):
+            for s_kind, s_at, s_next in stored:
+                if s_kind == kind and s_next and abs(s_at - at) <= 2000:
+                    return s_next
+            return None
+
+        def event(kind, stamp, next_stamp=None, pinned=False):
             at = _finite(stamp) / 1000
             if kind not in PACE or at <= 0:
                 return
@@ -300,8 +320,15 @@ class RuntimeGuard:
                                   "WHERE kind=? AND status='sent' AND token<>'' AND ABS(at-?)<=2 "
                                   "ORDER BY ABS(at-?) LIMIT 1", (kind, at, at)).fetchone()
             if native:
-                conn.execute("UPDATE guard_pace_events SET next=MAX(next,?) WHERE event_key=?",
-                             (free, native["event_key"]))
+                # The host already pinned this interval (one random draw, shown in the GUI).
+                # Python's own independent draw must not silently lengthen it — otherwise the
+                # UI says "40s left" while the native guard still waits 90s.
+                if pinned:
+                    conn.execute("UPDATE guard_pace_events SET next=? WHERE event_key=?",
+                                 (free, native["event_key"]))
+                else:
+                    conn.execute("UPDATE guard_pace_events SET next=MAX(next,?) WHERE event_key=?",
+                                 (free, native["event_key"]))
                 return
             key = f"seed:{kind}:{int(round(at * 1000))}"
             conn.execute("INSERT INTO guard_pace_events(event_key,kind,at,next,status,token) "
@@ -311,13 +338,11 @@ class RuntimeGuard:
         recent = raw.get("recent")
         for row in (recent[-200:] if isinstance(recent, list) else []):
             if isinstance(row, dict):
-                event(str(row.get("k") or ""), row.get("t"))
-        last = raw.get("last")
-        for kind, row in (last.items() if isinstance(last, dict) else []):
-            if isinstance(row, dict):
-                event(kind, row.get("at"), row.get("next"))
-            else:
-                event(kind, row)
+                kind, at = str(row.get("k") or ""), _finite(row.get("t"))
+                nxt = recorded_next(kind, at)
+                event(kind, at, nxt, pinned=nxt is not None)
+        for kind, at, nxt in stored:
+            event(kind, at, nxt, pinned=nxt is not None)
         book = self._pace_state(conn)
         cool = _finite(raw.get("cooldownUntil")) / 1000
         if cool > book["cooldown_until"]:

package/tests/automation-routes.test.mjs

@@ -1,183 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { EventEmitter } from 'node:events'
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs'
-import { createRequire, syncBuiltinESMExports } from 'node:module'
-import { join } from 'node:path'
-import { tmpdir } from 'node:os'
-import { apply } from '../index.js'
-import { learnAdd } from '../lib/learn.mjs'
-import { reviewMcpRequest } from '../lib/learn-review-mcp.mjs'
-
-test('schedule and review routes share background exclusion, persist days and isolate review decisions', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'fish-automation-routes-')), home = join(root, 'bili-duty')
-  mkdirSync(home)
-  const dummy = join(root, 'mock-cli.js'); writeFileSync(dummy, '// spawn is mocked')
-  writeFileSync(join(home, 'config.json'), JSON.stringify({ dshBin: dummy, learnAutoReview: false, backgroundModelId: 'background/model', backgroundMinutes: 4, learnReviewModelId: 'reviewer/model' }))
-  const stateFile = join(home, 'state.json'), pending = learnAdd({}, { text: '指出是哪一段有效，不照抄评论', from: 'BV1234567890' })
-  writeFileSync(stateFile, JSON.stringify({ learn: pending.ledger, unrelated: 77 }))
-  const children = [], spawned = [], cleanups = [], intervals = [], timers = []
-  let handler
-  const ctx = { logger: { info() {} }, get(key) { return key === 'llm' ? { listProviders: () => [{ id: 'background' }, { id: 'reviewer' }] } : key === 'dshHomePath' ? (...parts) => join(root, ...parts) : key === 'agents' ? { list: () => [] } : undefined },
-    tools: { register: tool => tool }, settings: { describe: () => [] }, on() { return () => {} },
-    effect(fn) { const cleanup = fn(); if (typeof cleanup === 'function') cleanups.push(cleanup) },
-    webServer: { register(route) { handler = route.handler; return { dispose() {} } } },
-  }
-  const actual = { setTimeout, clearTimeout, setInterval, clearInterval }
-  globalThis.setTimeout = (fn, ms) => { const t = { fn, ms, unref() {} }; timers.push(t); return t }
-  globalThis.clearTimeout = () => {}
-  globalThis.setInterval = (fn, ms) => { const t = { fn, ms, unref() {} }; intervals.push(t); return t }
-  globalThis.clearInterval = () => {}
-  const cp = createRequire(import.meta.url)('node:child_process'), actualSpawn = cp.spawn
-  cp.spawn = (command, args, opts) => {
-    spawned.push({ command, args, opts })
-    const child = new EventEmitter(); child.stdout = new EventEmitter(); child.stderr = new EventEmitter(); child.exitCode = null
-    child.kill = () => { child.killed = true; return true }; children.push(child); return child
-  }; syncBuiltinESMExports()
-  const state = () => JSON.parse(readFileSync(stateFile, 'utf8'))
-  async function request(path, body = {}, method = 'POST') {
-    const req = new EventEmitter(); req.url = '/api/bili-duty' + path; req.method = method; req.headers = {}; req.destroy = () => {}
-    const res = { writeHead(code) { this.code = code }, end(text) { this.body = JSON.parse(text) } }
-    const promise = handler(req, res)
-    if (method === 'POST') { req.emit('data', Buffer.from(JSON.stringify(body))); req.emit('end') }
-    await promise; return { statusCode: res.code, ...res.body }
-  }
-  try {
-    apply(ctx, {})
-    await new Promise(resolve => setImmediate(resolve))
-    assert.ok(intervals.some(t => t.ms === 15000)); assert.ok(timers.some(t => t.ms === 1500))
-    const cfg = await request('/config', {}, 'GET')
-    assert.equal(cfg.config.scheduleEnabled, false); assert.equal(cfg.config.learnAutoReview, false)
-    const launch = await request('/schedule', { scheduleEnabled: true, scheduleAllDay: true })
-    assert.equal(launch.started, true); assert.equal(spawned.length, 1); assert.equal(launch.schedule.ran, true)
-    assert.match(spawned[0].args.at(-1), /duty\.md/)
-    assert.equal((await request('/learn/review')).busy, true)
-    assert.equal((await request('/schedule', { action: 'check' })).busy, true)
-    children[0].exitCode = 0; children[0].emit('exit', 0)
-    assert.equal((await request('/learn/review')).busy, true, 'wait for final stdio before releasing worker')
-    children[0].emit('close', 0)
-    assert.equal((await request('/schedule', { action: 'check' })).schedule.ran, true)
-    assert.equal(spawned.length, 1)
-    assert.equal(state().unrelated, 77)
-
-    // Restarting from the same home keeps today's start consumed.
-    for (const cleanup of cleanups.splice(0).reverse()) cleanup()
-    apply(ctx, {})
-    await new Promise(resolve => setImmediate(resolve))
-    await request('/schedule', { action: 'check' }); assert.equal(spawned.length, 1)
-
-    // The next failed spawn must release its own marker and retain a retry cooldown.
-    const fresh = state(); fresh.schedule = {}; writeFileSync(stateFile, JSON.stringify(fresh))
-    assert.equal((await request('/schedule', { action: 'check' })).started, true)
-    children[1].emit('error', new Error('ENOENT fixture'))
-    const afterFailure = await request('/schedule', { action: 'check' })
-    assert.equal(afterFailure.schedule.ran, false); assert.match(afterFailure.schedule.lastError, /ENOENT/)
-    assert.equal(spawned.length, 2)
-    await request('/schedule', { scheduleEnabled: false })
-
-    const review = await request('/learn/review')
-    assert.equal(review.started, true); assert.equal(spawned.length, 3)
-    const overlay = readFileSync(join(home, 'headless-learn-review-overlay.yml'), 'utf8')
-    assert.match(overlay, /mcp-dafeiyu-learn-review/); assert.match(overlay, /learn-review-mcp\.mjs/)
-    assert.match(overlay, /provider: 'dafeiyu-parent'/); assert.match(overlay, /model: 'reviewer\/model'/)
-    assert.match(overlay, /model-relay-adapter\.mjs/); assert.doesNotMatch(overlay, /BILI_DUTY_RELAY_CAPABILITY|BILI_MCP_TOOLS/)
-    assert.match(spawned[2].opts.env.BILI_DUTY_RELAY_CAPABILITY, /^[a-f0-9]{64}$/)
-    assert.doesNotMatch(spawned[2].args.at(-1), /先看自己的作品/)
-    const manifestFile = join(home, review.learnReview.id + '.json'), manifest = JSON.parse(readFileSync(manifestFile, 'utf8'))
-    const reply = reviewMcpRequest({ id: 5, method: 'tools/call', params: { name: 'bili_learn', arguments: { action: 'approve', id: pending.id, why: '具体、可复用且有来源' } } }, manifest, { stateFile, manifestFile })
-    assert.equal(reply.result.isError, false)
-    assert.equal(state().learn.items[pending.id].state, 'approved')
-    await request('/config', { learnReviewModelId: 'background/next-review' })
-    const liveReview = (await request('/learn/review', {}, 'GET')).learnReview
-    assert.equal(liveReview.running, true); assert.equal(liveReview.approved, 1); assert.equal(liveReview.remaining, 0)
-    assert.equal(liveReview.model, 'reviewer/model', 'current run keeps its actual model when next-run settings change')
-    assert.equal((await request('/learn/review', { action: 'stop' })).stopped, true)
-    assert.equal(existsSync(manifestFile), false)
-    const revoked = reviewMcpRequest({ id: 6, method: 'tools/call', params: { name: 'bili_learn', arguments: { action: 'reject', id: pending.id, why: 'stale worker' } } }, manifest, { stateFile, manifestFile })
-    assert.match(revoked.result.content[0].text, /REVIEW_RUN_REVOKED/)
-    assert.equal((await request('/pet/start', { mode: 'background' })).busy, true)
-    children[2].emit('close', null)
-    await request('/schedule', { action: 'check' })
-    const reviewDone = await request('/learn/review', {}, 'GET')
-    assert.equal(reviewDone.learnReview.running, false); assert.equal(reviewDone.learnReview.approved, 1)
-    assert.equal(reviewDone.learnReview.stopReason, 'user')
-    assert.equal(state().unrelated, 77)
-    const log = await request('/pet/log?n=500', {}, 'GET')
-    for (const type of ['schedule-start', 'schedule-error', 'learn-review-start', 'learn-review-done']) assert.ok(log.entries.some(row => row.type === type), type)
-    const bad = await request('/learn/review', { action: 'approve' }); assert.equal(bad.statusCode, 400)
-  } finally {
-    for (const cleanup of cleanups.reverse()) { try { cleanup() } catch {} }
-    Object.assign(globalThis, actual); cp.spawn = actualSpawn; syncBuiltinESMExports()
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('default automatic review starts on idle startup, respects retry and off switch, then finishes pending work', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'fish-auto-review-')), home = join(root, 'bili-duty')
-  mkdirSync(home)
-  const dummy = join(root, 'mock-cli.js'); writeFileSync(dummy, '// spawn is mocked')
-  writeFileSync(join(home, 'config.json'), JSON.stringify({ dshBin: dummy, backgroundModelId: 'reviewer/model' }))
-  const stateFile = join(home, 'state.json'), pending = learnAdd({}, { text: '说明具体场景，再决定如何接话', from: 'BV1234567890' })
-  writeFileSync(stateFile, JSON.stringify({ learn: pending.ledger, unrelated: 99 }))
-  const children = [], spawned = [], cleanups = [], intervals = [], timers = []
-  let handler
-  const ctx = { logger: { info() {} }, get(key) { return key === 'llm' ? { listProviders: () => [{ id: 'reviewer' }] } : key === 'dshHomePath' ? (...parts) => join(root, ...parts) : key === 'agents' ? { list: () => [] } : undefined },
-    tools: { register: tool => tool }, settings: { describe: () => [] }, on() { return () => {} },
-    effect(fn) { const cleanup = fn(); if (typeof cleanup === 'function') cleanups.push(cleanup) },
-    webServer: { register(route) { handler = route.handler; return { dispose() {} } } },
-  }
-  const actual = { setTimeout, clearTimeout, setInterval, clearInterval }
-  globalThis.setTimeout = (fn, ms) => { const t = { fn, ms, unref() {} }; timers.push(t); return t }
-  globalThis.clearTimeout = () => {}
-  globalThis.setInterval = (fn, ms) => { const t = { fn, ms, unref() {} }; intervals.push(t); return t }
-  globalThis.clearInterval = () => {}
-  const cp = createRequire(import.meta.url)('node:child_process'), actualSpawn = cp.spawn
-  cp.spawn = (command, args, opts) => {
-    spawned.push({ command, args, opts })
-    const child = new EventEmitter(); child.stdout = new EventEmitter(); child.stderr = new EventEmitter(); child.exitCode = null
-    child.kill = () => true; children.push(child); return child
-  }; syncBuiltinESMExports()
-  const flush = () => new Promise(resolve => setImmediate(resolve))
-  async function request(path, body, method = 'GET') {
-    const req = new EventEmitter(); req.url = '/api/bili-duty' + path; req.method = method; req.headers = {}; req.destroy = () => {}
-    const res = { writeHead(code) { this.code = code }, end(text) { this.body = JSON.parse(text) } }
-    const promise = handler(req, res)
-    if (method === 'POST') { req.emit('data', Buffer.from(JSON.stringify(body || {}))); req.emit('end') }
-    await promise; return res.body
-  }
-  try {
-    apply(ctx, {}); await flush()
-    assert.equal((await request('/config')).config.learnAutoReview, true)
-    const startup = timers.find(t => t.ms === 1500), interval = intervals.find(t => t.ms === 15000)
-    startup.fn(); await flush()
-    assert.equal(spawned.length, 1, 'startup automatically launches pending review without a manual request')
-    assert.match(spawned[0].args.at(-1), /独立的学习队列模型审核任务/)
-    assert.equal((await request('/learn/review')).learnReview.model, 'reviewer/model', 'empty reviewer setting uses background model')
-    interval.fn(); await flush(); assert.equal(spawned.length, 1, 'busy worker is never duplicated')
-    children[0].emit('close', 0); await flush()
-    const incomplete = (await request('/learn/review')).learnReview
-    assert.equal(incomplete.complete, false); assert.equal(incomplete.pending, 1)
-    assert.ok(incomplete.nextRetryAt > Date.now()); assert.equal(incomplete.remaining, 1)
-    interval.fn(); await flush(); assert.equal(spawned.length, 1, 'zero exit with unprocessed pending work respects backoff')
-    const ready = JSON.parse(readFileSync(stateFile, 'utf8'))
-    ready.learnReview.lastAttemptAt = Date.now() - 180001; ready.learnReview.nextRetryAt = Date.now() - 1
-    writeFileSync(stateFile, JSON.stringify(ready))
-    await request('/config', { learnAutoReview: false }, 'POST')
-    interval.fn(); await flush(); assert.equal(spawned.length, 1, 'explicit off is preserved')
-    await request('/config', { learnAutoReview: true }, 'POST')
-    interval.fn(); await flush(); assert.equal(spawned.length, 2, 'idle scheduler resumes pending review after cooldown')
-    const running = (await request('/learn/review')).learnReview
-    const manifestFile = join(home, running.id + '.json'), manifest = JSON.parse(readFileSync(manifestFile, 'utf8'))
-    const reply = reviewMcpRequest({ id: 9, method: 'tools/call', params: { name: 'bili_learn', arguments: { action: 'approve', id: pending.id, why: '具体、可复用且有来源' } } }, manifest, { stateFile, manifestFile })
-    assert.equal(reply.result.isError, false)
-    children[1].emit('close', 0); await flush()
-    const complete = (await request('/learn/review')).learnReview
-    assert.equal(complete.complete, true); assert.equal(complete.approved, 1); assert.equal(complete.pending, 0)
-    assert.equal(JSON.parse(readFileSync(stateFile, 'utf8')).unrelated, 99)
-    interval.fn(); await flush(); assert.equal(spawned.length, 2, 'empty pending queue stays idle')
-  } finally {
-    for (const cleanup of cleanups.reverse()) { try { cleanup() } catch {} }
-    Object.assign(globalThis, actual); cp.spawn = actualSpawn; syncBuiltinESMExports()
-    rmSync(root, { recursive: true, force: true })
-  }
-})

package/tests/automation.test.mjs

@@ -1,79 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { tmpdir } from 'node:os'
-import { AUTOMATION_DEFAULTS, clampAutomationSettings, dailyScheduleStatus, markDailyStarted, releaseDailyStart } from '../lib/automation.mjs'
-import { learnAdd, learnDecide, learnInject } from '../lib/learn.mjs'
-import { learningReviewBatch, buildLearningReviewPrompt, decideLearningReview } from '../lib/learn-review.mjs'
-import { reviewMcpRequest } from '../lib/learn-review-mcp.mjs'
-import { readRecordEvents } from '../lib/records.mjs'
-
-const local = (h, m = 0, day = 8) => new Date(2026, 0, day, h, m)
-const config = { scheduleEnabled: true, scheduleStart: '18:00', scheduleEnd: '09:00' }
-test('daily windows are local, half-open, cross midnight and persist consumed days', () => {
-  assert.equal(AUTOMATION_DEFAULTS.scheduleEnabled, false)
-  assert.equal(AUTOMATION_DEFAULTS.learnAutoReview, true)
-  assert.equal(dailyScheduleStatus(config, {}, local(17, 59)).due, false)
-  const open = dailyScheduleStatus(config, {}, local(18))
-  assert.equal(open.due, true); assert.equal(open.windowDay, '2026-01-08')
-  assert.equal(dailyScheduleStatus(config, {}, local(8, 59, 9)).windowDay, '2026-01-08')
-  assert.equal(dailyScheduleStatus(config, {}, local(9)).inWindow, false)
-  const record = markDailyStarted({}, open.windowDay, local(18), 'one')
-  assert.equal(dailyScheduleStatus(config, JSON.parse(JSON.stringify(record)), local(8, 0, 9)).due, false)
-  assert.equal(new Date(dailyScheduleStatus(config, record, local(8, 0, 9)).nextRunAt).getTime(), local(18, 0, 9).getTime())
-  assert.equal(dailyScheduleStatus(config, record, local(18, 0, 9)).due, true)
-  assert.equal(releaseDailyStart(record, 'stale', 'error'), record)
-  assert.equal(dailyScheduleStatus(config, releaseDailyStart(record, 'one', 'ENOENT'), local(19)).due, true)
-})
-test('all day, empty/equal clocks, ordinary window boundaries and clamps', () => {
-  const allDay = { ...config, scheduleAllDay: true }
-  assert.equal(dailyScheduleStatus(allDay, {}, local(0)).due, true)
-  assert.equal(dailyScheduleStatus({ ...config, scheduleEnabled: false }, {}, local(19)).nextRunAt, null)
-  assert.equal(dailyScheduleStatus({ ...config, scheduleStart: '09:00', scheduleEnd: '09:00' }, {}, local(12)).due, false)
-  const sameDay = { ...config, scheduleStart: '09:00', scheduleEnd: '17:00' }
-  assert.equal(dailyScheduleStatus(sameDay, {}, local(9)).due, true)
-  assert.equal(dailyScheduleStatus(sameDay, {}, local(17)).due, false)
-  assert.deepEqual(clampAutomationSettings({ scheduleStart: '3:04', scheduleEnd: '29:99', learnReviewBatchSize: 999, learnReviewMinutes: 0, learnReviewTokenBudget: -1 }),
-    { scheduleStart: '03:04', scheduleEnd: '09:00', learnReviewBatchSize: 50, learnReviewMinutes: 1, learnReviewTokenBudget: 0 })
-})
-test('review decisions accept only unchanged pending records with a reason and preserve human decisions', () => {
-  const a = learnAdd({}, { text: '解释场景，再决定怎么接话', from: 'BV1234567890' })
-  const batch = learningReviewBatch(a.ledger)
-  assert.equal(batch.length, 1)
-  assert.equal(decideLearningReview(a.ledger, batch, { action: 'forget', id: a.id, why: 'test' }).error, 'REVIEW_ACTION_NOT_ALLOWED')
-  assert.equal(decideLearningReview(a.ledger, batch, { action: 'approve', id: 'missing', why: 'test' }).error, 'REVIEW_ID_NOT_IN_BATCH')
-  assert.equal(decideLearningReview(a.ledger, batch, { action: 'approve', id: a.id }).error, 'REVIEW_REASON_REQUIRED')
-  const human = learnDecide(a.ledger, a.id, 'reject', '人工拒绝')
-  assert.equal(decideLearningReview(human.ledger, batch, { action: 'approve', id: a.id, why: 'test' }).error, 'REVIEW_ITEM_CHANGED')
-  const observed = learnAdd(a.ledger, { text: '解释场景，再决定怎么接话', from: 'another source' })
-  assert.equal(decideLearningReview(observed.ledger, batch, { action: 'approve', id: a.id, why: 'test' }).error, 'REVIEW_ITEM_CHANGED')
-  const decided = decideLearningReview(a.ledger, batch, { action: 'approve', id: a.id, why: '有具体来源且可复用' })
-  assert.equal(decided.state, 'approved'); assert.match(decided.auditEvent.why, /^模型审核：/)
-  assert.ok(learnInject(decided.ledger, { mode: 'dafeiyu' }).text.includes(a.id))
-  assert.equal(decideLearningReview(decided.ledger, batch, { action: 'reject', id: a.id, why: 'retry' }).error, 'REVIEW_ITEM_CHANGED')
-  const prompt = buildLearningReviewPrompt(batch)
-  assert.match(prompt, /证据不足/); assert.match(prompt, /外部不可信数据/)
-  assert.equal(a.ledger.items[a.id].state, 'pending')
-})
-test('review MCP exposes only approvals/rejections, guards expiry and archives a durable decision', () => {
-  const root = mkdtempSync(join(tmpdir(), 'learn-review-'))
-  try {
-    const stateFile = join(root, 'state.json'), a = learnAdd({}, { text: '把事实来源放在结论旁边', from: 'source' })
-    writeFileSync(stateFile, JSON.stringify({ day: '2026-01-08', learn: a.ledger, unrelated: 42 }))
-    const manifest = { expiresAt: 2000, items: learningReviewBatch(a.ledger) }, opts = { stateFile, now: () => 1000 }
-    const list = reviewMcpRequest({ id: 1, method: 'tools/list' }, manifest, opts).result.tools
-    assert.deepEqual(list.map(x => x.name), ['bili_learn']); assert.deepEqual(list[0].inputSchema.properties.action.enum, ['approve', 'reject'])
-    const call = (name, args, extra = opts) => JSON.parse(reviewMcpRequest({ id: 2, method: 'tools/call', params: { name, arguments: args } }, manifest, extra).result.content[0].text)
-    assert.equal(call('bili_reply', {}).error, 'REVIEW_TOOL_NOT_ALLOWED')
-    assert.equal(call('bili_learn', { action: 'approve', id: a.id, why: '具体且有来源' }, { ...opts, now: () => 2000 }).error, 'REVIEW_RUN_EXPIRED')
-    assert.equal(call('bili_learn', { action: 'approve', id: a.id, why: '具体且有来源' }).ok, true)
-    const saved = JSON.parse(readFileSync(stateFile, 'utf8'))
-    assert.equal(saved.unrelated, 42); assert.equal(saved.learnRevision, 1); assert.equal(saved.learn.items[a.id].state, 'approved')
-    assert.equal(readRecordEvents(root, { type: 'learning' }).length, 1)
-    assert.equal(call('bili_learn', { action: 'approve', id: a.id, why: 'duplicate' }).error, 'REVIEW_ITEM_CHANGED')
-    writeFileSync(stateFile, '{corrupt')
-    assert.equal(call('bili_learn', { action: 'reject', id: a.id, why: 'test' }).ok, false)
-    assert.equal(readFileSync(stateFile, 'utf8'), '{corrupt')
-  } finally { rmSync(root, { recursive: true, force: true }) }
-})

package/tests/background-tools.test.mjs

@@ -1,182 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { EventEmitter } from 'node:events'
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { createRequire, syncBuiltinESMExports } from 'node:module'
-import { apply } from '../index.js'
-import { createRelayClient, createRelayAdapter } from '../lib/model-relay-adapter.mjs'
-import { RELAY_PROVIDER } from '../lib/model-relay.mjs'
-import { McpClient } from '../lib/mcp.mjs'
-import { backgroundMcpRequest } from '../lib/background-mcp.mjs'
-import { backgroundToolNames, toolInputSchema, validateToolArguments } from '../lib/background-tools.mjs'
-
-// No Python, credentials or Bilibili requests: exercise the real parent wrappers via localhost MCP.
-test('background MCP shares host activity, pending learning, usage and live automation switches', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'fish-tool-bridge-')), home = join(root, 'bili-duty')
-  mkdirSync(home)
-  const cli = join(root, 'mock-cli.js'); writeFileSync(cli, '// child spawn mocked')
-  writeFileSync(join(home, 'config.json'), JSON.stringify({ dshBin: cli, learnAutoReview: false, backgroundModelId: 'buddy/fixture', reportLevel: 'off', replyToComments: true, autoComment: false, autoReplyDm: false }))
-  const cp = createRequire(import.meta.url)('node:child_process'), originalSpawn = cp.spawn, cleanups = [], registered = new Map()
-  let handler, childEnv, child
-  cp.spawn = (command, args, options) => {
-    childEnv = options.env
-    child = new EventEmitter(); child.stdout = new EventEmitter(); child.stderr = new EventEmitter(); child.exitCode = null
-    child.kill = () => true
-    return child
-  }; syncBuiltinESMExports()
-  let streams = 0
-  const llm = {
-    listProviders: () => [{ id: 'buddy' }],
-    resolveModelInfo: async (provider, id) => ({ provider, id, name: id, context: { contextWindow: 8192 } }),
-    prepareCall: async config => ({ config, async *stream() {
-      yield { type: 'text-delta', index: 0, text: 'fixture reply' }
-      if (++streams <= 2) yield { type: 'usage', usage: { inputTokens: 17, outputTokens: 3, cacheReadTokens: 10 } }
-      yield { type: 'finish', reason: { kind: 'stop' } }
-    } }),
-  }
-  const ctx = {
-    logger: { info() {} },
-    get: key => key === 'llm' ? llm : key === 'dshHomePath' ? (...parts) => join(root, ...parts) : key === 'agents' ? { list: () => [] } : undefined,
-    tools: { register(spec) { registered.set(spec.name, spec); return spec } }, settings: { describe: () => [] }, on() { return () => {} },
-    effect(fn) { const cleanup = fn(); if (typeof cleanup === 'function') cleanups.push(cleanup) },
-    webServer: { register(route) { handler = route.handler; return { dispose() {} } } },
-  }
-  async function request(path, body = {}, method = 'POST') {
-    const req = new EventEmitter(); req.url = '/api/bili-duty' + path; req.method = method; req.headers = {}; req.destroy = () => {}
-    const res = { writeHead(code) { this.code = code }, end(text) { this.body = JSON.parse(text) } }
-    const pending = handler(req, res)
-    if (method === 'POST') { req.emit('data', Buffer.from(JSON.stringify(body))); req.emit('end') }
-    await pending; return { statusCode: res.code, ...res.body }
-  }
-  try {
-    apply(ctx, {}); await new Promise(resolve => setImmediate(resolve))
-    assert.equal((await request('/pet/start', { mode: 'background' })).started, true)
-    const overlay = readFileSync(join(home, 'headless-overlay.yml'), 'utf8')
-    assert.match(overlay, /background-mcp\.mjs/); assert.doesNotMatch(overlay, /mcp_server\.py|BILI_DUTY_RELAY_CAPABILITY/)
-    const client = createRelayClient(childEnv), list = (await backgroundMcpRequest({ id: 1, method: 'tools/list' }, client)).result.tools
-    assert.ok(list.some(x => x.name === 'bili_reply')); assert.ok(list.some(x => x.name === 'bili_learn'))
-    for (const name of ['bili_dm_reply', 'bili_moment', 'bili_config', 'bili_run', 'bili_setup']) assert.ok(!list.some(x => x.name === name), name)
-    assert.ok(!('force' in list.find(x => x.name === 'bili_reply').inputSchema.properties))
-    let seq = 1
-    const call = async (name, args) => {
-      const result = (await backgroundMcpRequest({ id: ++seq, method: 'tools/call', params: { name, arguments: args } }, client)).result
-      return { isError: result.isError, ...JSON.parse(result.content[0].text) }
-    }
-    const say = await call('bili_say', { text: '字幕没有来源，今天先空手。', bvid: null })
-    assert.equal(say.ok, true)
-    const activity = (await request('/activity', {}, 'GET')).rows
-    assert.ok(activity.some(x => x.kind === 'say' && /今天先空手/.test(x.text)))
-    const learned = await call('bili_learn', { action: 'add', kind: 'style', text: '先回应一个明确细节，再简短表达自己的感受', from: 'fixture:comment' })
-    assert.equal(learned.ok, true)
-    const state = () => JSON.parse(readFileSync(join(home, 'state.json'), 'utf8'))
-    assert.equal(state().learn.items[learned.id].state, 'pending')
-    const blockedApproval = await call('bili_learn', { action: 'approve', id: learned.id })
-    assert.equal(blockedApproval.isError, true)
-    assert.equal(state().learn.items[learned.id].state, 'pending')
-    assert.equal((await registered.get('bili_soul').execute({ action: 'read' }, {})).reason, 'mode_required')
-    assert.equal((await call('bili_reply', { bvid: 'BV1234567890', text: 'fixture', force: true })).isError, true)
-    await request('/config', { replyToComments: false })
-    const disabled = await call('bili_reply', { bvid: 'BV1234567890', text: 'fixture' })
-    assert.equal(disabled.isError, true); assert.match(disabled.error, /BACKGROUND_TOOL_DISABLED/)
-
-    const adapter = createRelayAdapter(childEnv)
-    for (let i = 0; i < 3; i++) for await (const _ of adapter.stream({ provider: RELAY_PROVIDER, model: 'buddy/fixture', messages: [] })) {}
-    // A state update is async; await an unrelated host request/turn before reading its persisted projection.
-    await new Promise(resolve => setImmediate(resolve))
-    assert.equal(state().tokensTotal, 60)
-    assert.equal(state().tokensToday, 60)
-    child.exitCode = 0; child.emit('close', 0)
-    const status = await request('/status', {}, 'GET')
-    assert.equal(status.backgroundRun.stopReason, 'exit')
-    assert.equal(status.backgroundRun.requests, 3)
-    assert.equal(status.backgroundRun.unknownRequests, 1)
-    const round = status.tokenRounds.entries[0]
-    assert.equal(round.tokensUnknown, false); assert.deepEqual(round.tokens, { input: 54, output: 6, total: 60 })
-    assert.equal(round.unknownRequests, 1)
-    assert.equal(status.tokenRounds.sums.partial, 1)
-    const log = (await request('/pet/log?n=500', {}, 'GET')).entries
-    assert.ok(log.some(x => x.type === 'bg-progress' && x.stage === 'tool-done' && /bili_say/.test(x.text)))
-    assert.ok(log.some(x => x.type === 'bg-done' && x.tokens?.total === 60 && x.unknownRequests === 1))
-    await assert.rejects(client.post({ action: 'tools-list' }), /撤销或过期/)
-  } finally {
-    for (const cleanup of cleanups.reverse()) { try { cleanup() } catch {} }
-    cp.spawn = originalSpawn; syncBuiltinESMExports()
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('stopping during DM qualification never submits a new send after the pending read returns', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'fish-stop-dm-')), home = join(root, 'bili-duty')
-  mkdirSync(home)
-  const cli = join(root, 'mock-cli.js'); writeFileSync(cli, '// child spawn mocked')
-  writeFileSync(join(home, 'config.json'), JSON.stringify({ dshBin: cli, learnAutoReview: false, backgroundModelId: 'buddy/fixture', reportLevel: 'off', autoReplyDm: true }))
-  const cp = createRequire(import.meta.url)('node:child_process'), originalSpawn = cp.spawn, originalCall = McpClient.prototype.call
-  const cleanups = []
-  let handler, childEnv, child, reads = 0, sends = 0, releaseRead, readStarted
-  const reading = new Promise(resolve => { readStarted = resolve })
-  const released = new Promise(resolve => { releaseRead = resolve })
-  const calls = []
-  cp.spawn = (command, args, options) => {
-    const proc = new EventEmitter(); proc.stdout = new EventEmitter(); proc.stderr = new EventEmitter(); proc.exitCode = null; proc.kill = () => true
-    if (options.env?.BILI_DUTY_RELAY_CAPABILITY) { child = proc; childEnv = options.env }
-    return proc
-  }; syncBuiltinESMExports()
-  McpClient.prototype.call = async function(name) {
-    calls.push(name)
-    if (name === 'bili_dm_list') {
-      if (++reads === 1) { readStarted(); await released }
-      return { items: [{ uid: '123', msg_seqno: '456', is_follow: true, days_ago: 0 }] }
-    }
-    if (name === 'bili_send_message') { sends++; return { success: true } }
-    throw new Error('unexpected MCP call ' + name)
-  }
-  const llm = { listProviders: () => [{ id: 'buddy' }] }
-  const ctx = {
-    logger: { info() {} }, get: key => key === 'llm' ? llm : key === 'dshHomePath' ? (...parts) => join(root, ...parts) : key === 'agents' ? { list: () => [] } : undefined,
-    tools: { register(spec) { return spec } }, settings: { describe: () => [] }, on() { return () => {} },
-    effect(fn) { const cleanup = fn(); if (typeof cleanup === 'function') cleanups.push(cleanup) },
-    webServer: { register(route) { handler = route.handler; return { dispose() {} } } },
-  }
-  async function request(path, body = {}) {
-    const req = new EventEmitter(); req.url = '/api/bili-duty' + path; req.method = 'POST'; req.headers = {}; req.destroy = () => {}
-    const res = { writeHead(code) { this.code = code }, end(text) { this.body = JSON.parse(text) } }
-    const pending = handler(req, res); req.emit('data', Buffer.from(JSON.stringify(body))); req.emit('end'); await pending
-    return res.body
-  }
-  try {
-    apply(ctx, {}); await new Promise(resolve => setImmediate(resolve))
-    assert.equal((await request('/pet/start', { mode: 'background' })).started, true)
-    const pending = backgroundMcpRequest({ id: 1, method: 'tools/call', params: { name: 'bili_dm_reply', arguments: { uid: '123', msg_seqno: '456', text: '这条先等一下，小鱼看到了。' } } }, createRelayClient(childEnv))
-    const settled = pending.then(value => value, error => ({ error }))
-    await reading
-    assert.equal((await request('/pet/stop')).stopped, true)
-    releaseRead(); await settled
-    await new Promise(resolve => setImmediate(resolve))
-    assert.equal(sends, 0)
-    assert.ok(!calls.includes('bili_send_message'))
-    child.emit('close', null)
-    // A fresh task still works: cancelled execution context must not bleed into it.
-    assert.equal((await request('/pet/start', { mode: 'background' })).started, true)
-    const result = await backgroundMcpRequest({ id: 2, method: 'tools/call', params: { name: 'bili_dm_reply', arguments: { uid: '123', msg_seqno: '456', text: '小鱼刚看到，先慢慢来呀。' } } }, createRelayClient(childEnv))
-    assert.equal(result.result.isError, false)
-    assert.equal(JSON.parse(result.result.content[0].text).success, true)
-    assert.equal(sends, 1)
-    child.emit('close', 0)
-  } finally {
-    releaseRead()
-    for (const cleanup of cleanups.reverse()) { try { cleanup() } catch {} }
-    cp.spawn = originalSpawn; syncBuiltinESMExports(); McpClient.prototype.call = originalCall
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('background schemas preserve ID strings and reject fabricated human authorization', () => {
-  const schema = toolInputSchema({ id: { type: 'string', required: true }, force: { type: 'boolean' }, action: { type: 'string', enum: ['read', 'add'] } })
-  assert.deepEqual(schema.required, ['id'])
-  assert.deepEqual(validateToolArguments(schema, { id: '1234567890123456789', action: null }), { id: '1234567890123456789' })
-  for (const bad of [{ id: 1234567890123456789 }, { id: 'x', force: true }, { id: 'x', action: 'approve' }, {}]) assert.throws(() => validateToolArguments(schema, bad), /BACKGROUND_TOOL_/)
-  assert.ok(!backgroundToolNames({}).includes('bili_reply'))
-  assert.ok(backgroundToolNames({ autoReplyDm: true }).includes('bili_dm_reply'))
-})

package/tests/background-window.test.mjs

@@ -1,75 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { parseHM, backgroundWindowActive, backgroundWindowEndAt, backgroundWindowLaunch } from '../lib/run-settings.mjs'
-
-/* 后台「时段」任务的纯函数（2026-10-28）：指定 start–end，段内一直刷。
- * 单测钉三类边界：常规段 / 跨午夜段（重启后接着刷尾段）/ 非法与相等段。 */
-const at = (h, m, day = 28) => new Date(2026, 9, day, h, m, 0, 0) // 2026-10-28（周三）
-
-test('parseHM 只认 00:00–23:59', () => {
-  assert.deepEqual(parseHM('20:00'), { h: 20, m: 0 })
-  assert.deepEqual(parseHM(' 9:05 '), { h: 9, m: 5 })
-  assert.equal(parseHM('24:00'), null)
-  assert.equal(parseHM('20:60'), null)
-  assert.equal(parseHM('20'), null)
-  assert.equal(parseHM(''), null)
-  assert.equal(parseHM(null), null)
-})
-
-test('常规段：end 在 start 之后 ⇒ 今天结束；段外也已返回今天的 end（由调用方判断是否过期）', () => {
-  assert.equal(backgroundWindowEndAt('20:00', '23:00', at(20, 30)), at(23, 0).getTime())
-  assert.equal(backgroundWindowEndAt('09:00', '12:00', at(10, 0)), at(12, 0).getTime())
-  assert.equal(backgroundWindowEndAt('09:00', '12:00', at(8, 0)), at(12, 0).getTime())
-})
-
-test('跨午夜段：晚间主体 ⇒ 结束在次日；半夜重启接着刷尾段 ⇒ 结束就在今天', () => {
-  assert.equal(backgroundWindowEndAt('20:00', '02:00', at(20, 30)), new Date(2026, 9, 29, 2, 0).getTime())
-  assert.equal(backgroundWindowEndAt('20:00', '02:00', at(23, 59)), new Date(2026, 9, 29, 2, 0).getTime())
-  assert.equal(backgroundWindowEndAt('20:00', '02:00', at(1, 30)), at(2, 0).getTime())
-  assert.equal(backgroundWindowEndAt('22:00', '00:00', at(22, 5)), new Date(2026, 9, 29, 0, 0).getTime())
-  assert.equal(backgroundWindowEndAt('22:00', '00:00', at(0, 10)), at(0, 0).getTime())
-})
-
-test('start==end 或解析失败 ⇒ null（视为没配时段）', () => {
-  assert.equal(backgroundWindowEndAt('20:00', '20:00', at(20, 0)), null)
-  assert.equal(backgroundWindowEndAt('abc', '23:00', at(20, 0)), null)
-  assert.equal(backgroundWindowEndAt('', '', at(20, 0)), null)
-})
-
-test('backgroundWindowActive：[start, end) 左闭右开，跨午夜两段都算', () => {
-  assert.equal(backgroundWindowActive('20:00', '23:00', at(20, 0)), true)
-  assert.equal(backgroundWindowActive('20:00', '23:00', at(22, 59)), true)
-  assert.equal(backgroundWindowActive('20:00', '23:00', at(23, 0)), false)
-  assert.equal(backgroundWindowActive('20:00', '23:00', at(19, 59)), false)
-  assert.equal(backgroundWindowActive('20:00', '02:00', at(21, 0)), true)
-  assert.equal(backgroundWindowActive('20:00', '02:00', at(0, 30)), true)
-  assert.equal(backgroundWindowActive('20:00', '02:00', at(2, 0)), false)
-  assert.equal(backgroundWindowActive('20:00', '02:00', at(19, 59)), false)
-  assert.equal(backgroundWindowActive('20:00', '20:00', at(20, 0)), false)
-  assert.equal(backgroundWindowActive('x', 'y', at(20, 0)), false)
-})
-
-test('backgroundWindowLaunch：这一跳要不要拉起鱼（常设时段任务的核心决策）', () => {
-  const cfg = { backgroundWindowStart: '20:00', backgroundWindowEnd: '23:00' }
-  // 段内、没挂免跑牌 ⇒ 拉起，endAt = 今天 23:00，剩余整算成分钟
-  const hit = backgroundWindowLaunch(cfg, {}, at(20, 30))
-  assert.equal(hit.endAt, at(23, 0).getTime())
-  assert.equal(hit.remainMin, 150)
-  // 不在段内（含结束边界）/ 没配 / start==end ⇒ null
-  assert.equal(backgroundWindowLaunch(cfg, {}, at(19, 59)), null)
-  assert.equal(backgroundWindowLaunch(cfg, {}, at(23, 0)), null)
-  assert.equal(backgroundWindowLaunch({}, {}, at(21, 0)), null)
-  assert.equal(backgroundWindowLaunch({ backgroundWindowStart: '20:00', backgroundWindowEnd: '20:00' }, {}, at(20, 0)), null)
-  // 免跑牌：hold 在未来 ⇒ 不拉（手动停止后调度钩子认账）；hold 已过期 ⇒ 照常拉
-  assert.equal(backgroundWindowLaunch(cfg, { bgWindowHold: at(21, 0).getTime() }, at(20, 30)), null)
-  const after = backgroundWindowLaunch(cfg, { bgWindowHold: at(20, 0).getTime() }, at(20, 30))
-  assert.equal(after.endAt, at(23, 0).getTime())
-  // 跨午夜段：半夜尾段 ⇒ endAt 就是今天；晚间主体 ⇒ 次天
-  const nightTail = backgroundWindowLaunch({ backgroundWindowStart: '20:00', backgroundWindowEnd: '02:00' }, {}, at(1, 0))
-  assert.equal(nightTail.endAt, at(2, 0).getTime())
-  const nightMain = backgroundWindowLaunch({ backgroundWindowStart: '20:00', backgroundWindowEnd: '02:00' }, {}, at(21, 0))
-  assert.equal(nightMain.endAt, new Date(2026, 9, 29, 2, 0).getTime())
-  // 段尾剩余 <1 分钟 ⇒ remainMin 兜底 1（别出 0 分钟的任务）
-  const tail = backgroundWindowLaunch(cfg, {}, at(22, 59))
-  assert.equal(tail.remainMin, 1)
-})