dsh-deepmoyu 2.3.0 → 2.4.2

package/tests/model-relay.test.mjs

@@ -1,116 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { createModelRelay, RELAY_PROVIDER, splitModelRoute, usageTokens } from '../lib/model-relay.mjs'
-import { createRelayAdapter } from '../lib/model-relay-adapter.mjs'
-
-const model = 'buddy/glm-5.3-flash'
-function fakeLlm(overrides = {}) {
-  const calls = []
-  return {
-    calls,
-    listProviders: () => [{ id: 'buddy', name: 'Buddy' }],
-    async resolveModelInfo(provider, id) { return { provider, id, name: id, context: { contextWindow: 131072 }, defaultMaxTokens: 8192 } },
-    async prepareCall(config, signal) {
-      calls.push({ config, signal })
-      return { config: { ...config, maxTokens: config.maxTokens || 8192 }, async *stream(options) {
-        assert.equal(options.provider, 'buddy'); assert.equal(options.model, 'glm-5.3-flash')
-        assert.equal(options.maxTokens, 8192)
-        assert.equal(options.messages[0].source.provider, 'buddy')
-        assert.equal(options.messages[0].source.model, 'glm-5.3-flash')
-        assert.equal(options.attribution, undefined)
-        yield { type: 'text-delta', index: 0, text: '小鱼找到一条！' }
-        yield { type: 'tool-call-delta', index: 1, id: 'call-a', name: 'bili_search', argumentsDelta: '{}' }
-        yield { type: 'usage', usage: { inputTokens: 10, outputTokens: 5, cacheReadTokens: 20 } }
-        yield { type: 'usage', usage: { inputTokens: 10, outputTokens: 6, cacheReadTokens: 20, totalTokens: 36 } }
-        yield { type: 'finish', reason: { kind: 'stop' } }
-      } }
-    },
-    ...overrides,
-  }
-}
-const messages = [{ role: 'assistant', source: { kind: 'model', provider: RELAY_PROVIDER, model, replayState: { ok: true } }, content: [{ type: 'text', text: 'old reply' }] }]
-
-test('parent relay streams the exact configured model with prepared defaults and final usage once', async () => {
-  const usage = [], events = [], llm = fakeLlm()
-  const relay = createModelRelay({ getLlm: () => llm })
-  try {
-    assert.equal(await relay.ready, true)
-    const grant = relay.open(model, { onUsage: x => usage.push(x), onEvent: x => events.push(x) })
-    const adapter = createRelayAdapter(grant.env)
-    const info = await adapter.resolveModel(RELAY_PROVIDER, model)
-    assert.equal(info.provider, RELAY_PROVIDER); assert.equal(info.id, model); assert.equal(info.context.contextWindow, 131072)
-    const prepared = await adapter.prepareCall(RELAY_PROVIDER, model)
-    const chunks = []
-    for await (const chunk of prepared.stream({ provider: RELAY_PROVIDER, model, messages, attribution: { sessionId: 'not-forwarded' } })) chunks.push(chunk)
-    assert.equal(chunks[0].text, '小鱼找到一条！')
-    assert.deepEqual(llm.calls[0].config, { provider: 'buddy', model: 'glm-5.3-flash' })
-    assert.deepEqual(usage, [{ input: 30, output: 6, total: 36 }])
-    assert.ok(events.some(e => e.stage === 'tool' && /bili_search/.test(e.text)))
-    assert.ok(events.some(e => e.stage === 'model-done'))
-    assert.equal(adapter.providerRetryPolicy().maxRetries, 0)
-    grant.revoke()
-    await assert.rejects(adapter.resolveModel(RELAY_PROVIDER, model), /撤销或过期/)
-  } finally { relay.close() }
-})
-
-test('capabilities reject browser origins, unauthorized use, route override, and unavailable parent adapters', async () => {
-  const relay = createModelRelay({ getLlm: () => fakeLlm() })
-  try {
-    await relay.ready
-    assert.throws(() => relay.open('other/model'), /没有注册/)
-    const grant = relay.open(model)
-    const url = grant.env.BILI_DUTY_RELAY_URL, auth = 'Bearer ' + grant.env.BILI_DUTY_RELAY_CAPABILITY
-    assert.equal((await fetch(url, { method: 'POST', body: '{}' })).status, 403)
-    assert.equal((await fetch(url, { method: 'POST', headers: { authorization: auth, origin: 'http://127.0.0.1' }, body: '{}' })).status, 403)
-    const adapter = createRelayAdapter(grant.env)
-    await assert.rejects(adapter.resolveModel(RELAY_PROVIDER, 'other/model'), /路线/)
-    assert.throws(() => createRelayAdapter({ ...grant.env, BILI_DUTY_RELAY_URL: 'https://remote.invalid/call' }), /本机/)
-    grant.revoke()
-  } finally { relay.close() }
-})
-
-test('revoking a run aborts active model IO, never retries and closes the stream', async () => {
-  let started, aborted
-  const begin = new Promise(resolve => { started = resolve }), done = new Promise(resolve => { aborted = resolve })
-  const llm = fakeLlm({ async prepareCall(config, signal) {
-    return { config, async *stream() {
-      started()
-      await new Promise(resolve => { signal.addEventListener('abort', () => { aborted(); resolve() }, { once: true }) })
-      signal.throwIfAborted()
-    } }
-  } })
-  const relay = createModelRelay({ getLlm: () => llm })
-  try {
-    await relay.ready
-    const grant = relay.open(model), adapter = createRelayAdapter(grant.env)
-    const reading = (async () => { for await (const _ of adapter.stream({ provider: RELAY_PROVIDER, model, messages: [] })) {} })()
-    await begin; grant.revoke(); await done
-    await assert.rejects(reading)
-  } finally { relay.close() }
-})
-
-test('terminal errors are shown and partial measured usage is not lost on interruption', async () => {
-  const usage = [], events = []
-  const llm = fakeLlm({ async prepareCall(config) { return { config, async *stream() {
-    yield { type: 'usage', usage: { inputTokens: 11, outputTokens: 2 } }
-    yield { type: 'finish', reason: { kind: 'error', failure: { code: 'NO_ADAPTER', message: 'fixture failure' } } }
-  } } } })
-  const relay = createModelRelay({ getLlm: () => llm })
-  try {
-    await relay.ready
-    const grant = relay.open(model, { onUsage: x => usage.push(x), onEvent: x => events.push(x) })
-    const adapter = createRelayAdapter(grant.env)
-    for await (const _ of adapter.stream({ provider: RELAY_PROVIDER, model, messages: [] })) {}
-    assert.deepEqual(usage, [{ input: 11, output: 2, total: 13 }])
-    assert.ok(events.some(e => e.stage === 'model-error' && /fixture/.test(e.text)))
-    assert.ok(!events.some(e => e.stage === 'model-done'))
-  } finally { relay.close() }
-})
-
-test('model routes and usage validation never invent a route or estimate missing usage', () => {
-  assert.deepEqual(splitModelRoute(' buddy/path/model '), { provider: 'buddy', model: 'path/model' })
-  for (const route of ['', 'buddy', '/model', 'buddy/', 'buddy/model with space']) assert.throws(() => splitModelRoute(route))
-  assert.equal(usageTokens(undefined), null)
-  assert.equal(usageTokens({ inputTokens: 2 }), null)
-  assert.deepEqual(usageTokens({ inputTokens: 0, outputTokens: 0 }), { input: 0, output: 0, total: 0 })
-})

package/tests/persona.test.mjs

@@ -1,67 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { DAFEIYU_REPLY_GUIDE, DAFEIYU_REPLY_STYLE_RULES } from '../lib/persona.mjs'
-import { CHARACTER_COMPASS } from '../lib/mode.mjs'
-import { buildFeiyuObjective, buildLiveBrief } from '../lib/prompts.mjs'
-import { learnAdd, learnDecide, learnInject } from '../lib/learn.mjs'
-
-const base = {
-  cfg: { keywords: [], perDay: 5, momentPerDay: 1, dmMode: 'off', autoComment: true, replyToComments: true, autoReplyDm: false, autoMoment: false, reportLevel: 'brief' },
-  stateDir: 'C:/fixture/bili-duty',
-  outDir: 'C:/fixture/bili-duty/out',
-  digestDir: 'C:/fixture/bili-duty/digest',
-  charter: 'C:/fixture/bili-duty/duty.md',
-  day: '2026-10-27',
-}
-
-test('persona guide encodes natural, content-first fish replies without a catchphrase recipe', () => {
-  assert.match(DAFEIYU_REPLY_GUIDE, /先接住/)
-  assert.match(DAFEIYU_REPLY_GUIDE, /具体/)
-  assert.match(DAFEIYU_REPLY_GUIDE, /客服/)
-  assert.match(DAFEIYU_REPLY_GUIDE, /固定口癖/)
-  assert.equal(DAFEIYU_REPLY_STYLE_RULES.short, true)
-  assert.equal(DAFEIYU_REPLY_STYLE_RULES.contentFirst, true)
-  assert.equal(DAFEIYU_REPLY_STYLE_RULES.variableSelfReference, true)
-  assert.equal(DAFEIYU_REPLY_STYLE_RULES.variableEmotion, true)
-  assert.equal(DAFEIYU_REPLY_STYLE_RULES.noCustomerServiceTone, true)
-  assert.equal(DAFEIYU_REPLY_STYLE_RULES.noFixedCatchphrase, true)
-  assert.equal(DAFEIYU_REPLY_STYLE_RULES.maxKaomojiPerSentence, 1)
-  assert.doesNotMatch(DAFEIYU_REPLY_GUIDE, /示例句|固定回复|每句都/)
-})
-
-test('session objective carries the shared reply guide and stays non-template', () => {
-  const prompt = buildFeiyuObjective(base)
-  assert.ok(prompt.includes(DAFEIYU_REPLY_GUIDE))
-  assert.match(prompt, /先接住对方或内容里最具体的那一下/)
-  assert.match(prompt, /不要复述字幕、评论原话/)
-  assert.match(prompt, /不要写成客服/)
-  assert.doesNotMatch(prompt, /每条.*本鱼.*呜/)
-})
-
-test('live brief keeps the conversational boundary and does not turn into a report template', () => {
-  const prompt = buildLiveBrief({ ...base, picked: 1, moments: 0 })
-  assert.match(prompt, /输出像聊天/)
-  assert.match(prompt, /别说“本轮完成”/)
-  assert.match(prompt, /为您总结/)
-})
-
-test('approved learning remains reference-only while persona guidance stays authoritative', () => {
-  let ledger = {}
-  const added = learnAdd(ledger, { kind: 'style', text: '先说当下那一下，再补一句自己的反应', from: 'fixture-video' })
-  ledger = added.ledger
-  assert.equal(learnInject(ledger, { mode: 'dafeiyu', budget: 1200 }).text, '')
-  const decided = learnDecide(ledger, added.id, 'approve', '具体、可复用、来源清楚', '2026-10-27T00:00:00.000Z')
-  ledger = decided.ledger
-  const learned = learnInject(ledger, { mode: 'dafeiyu', budget: 1200 })
-  assert.match(learned.text, /先说当下那一下/)
-  const prompt = buildFeiyuObjective(base)
-  assert.ok(prompt.includes(DAFEIYU_REPLY_GUIDE))
-  assert.match(learned.text, /只是参考，不是必须照做/)
-})
-
-test('existing compass still keeps the fish identity boundary', () => {
-  assert.equal(typeof CHARACTER_COMPASS, 'string')
-  assert.ok(CHARACTER_COMPASS.includes('你是鲸鱼摸鱼'))
-  assert.ok(CHARACTER_COMPASS.includes('不报型号'))
-  assert.ok(CHARACTER_COMPASS.includes('公开评论、动态和私信仍各按授权与节奏开关'))
-})

package/tests/pet-run-routes.test.mjs

@@ -1,127 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { EventEmitter } from 'node:events'
-import { createRequire, syncBuiltinESMExports } from 'node:module'
-import { apply } from '../index.js'
-
-test('pet routes isolate defaults, enforce session budgets and safely stop background', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'pet-run-test-'))
-  const home = join(root, 'bili-duty'); mkdirSync(home)
-  const dummy = join(root, 'never-executed.js'); writeFileSync(dummy, '// never executed: spawn is mocked')
-  writeFileSync(join(home, 'config.json'), JSON.stringify({ dshBin: dummy, modelId: 'legacy/model', tokenBudget: 999999, maxRounds: 64, sessionModelId: 'saved/session', sessionTokenBudget: 9000, sessionMaxRounds: 16, sessionMinutes: 0, backgroundModelId: 'saved/background', backgroundTokenBudget: 7000, backgroundMinutes: 45 }))
-  const workspace = { id: 'current-workspace', path: root, sessionIds: ['fish-b'] }, createRequests = []
-  const permissionState = new Map()
-  const session = id => ({ header: { agentPreset: 'dafeiyu', cwd: root }, append(type, data) {
-    const state = permissionState.get(id) || {}
-    if (type === 'sandbox/mode') state.sandbox = data.mode
-    if (type === 'approval/policy') state.approval = data.policy
-    permissionState.set(id, state)
-  } })
-  const a = { id: 'fish-a', status: 'running', session: session('fish-a') }
-  const b = { id: 'fish-b', status: 'idle', session: session('fish-b') }
-  permissionState.set(a.id, { sandbox: 'workspace-write', approval: 'ask' })
-  permissionState.set(b.id, { sandbox: 'danger-full-access', approval: 'never' })
-  const agents = [a, b], goalsById = new Map(), selections = new Map(agents.map(x => [x.id, { current: { provider: 'default', model: 'model' } }]))
-  const usage = new Map(agents.map(x => [x.session, 0]))
-  const events = new Map(), cleanup = [], timeouts = [], children = [], spawned = []
-  let handler, seq = 0
-  const goals = {
-    get: agent => goalsById.get(agent.id),
-    create(agent, { objective, maxGoalRounds }) { const goal = { id: 'g' + ++seq, objective, maxGoalRounds, roundsStarted: 1, revision: 1, phase: 'active', activation: 'armed' }; goalsById.set(agent.id, goal); return goal },
-    pause(agent) { const g = goalsById.get(agent.id); g.phase = 'paused'; g.activation = 'disarmed'; return g },
-    resume(agent) { const g = goalsById.get(agent.id); g.phase = 'active'; g.activation = 'armed'; return g },
-    clear(agent) { const g = goalsById.get(agent.id); goalsById.delete(agent.id); return g },
-  }
-  const services = {
-    dshHomePath: (...parts) => join(root, ...parts), goals,
-    llm: { listProviders: () => ['explicit', 'saved', 'other'].map(id => ({ id })) },
-    agents: { get: id => agents.find(a => a.id === id), list: () => agents },
-    sessionController: { create: async request => { createRequests.push(request); workspace.sessionIds.push(a.id); return { sessionId: a.id } }, agents: { selectionFor: agent => selections.get(agent.id) } },
-    workspaceRegistry: { list: () => [workspace], get: id => id === workspace.id ? workspace : undefined, resolveByPath: async path => path === root ? workspace : undefined },
-    sessionProjections: { stateOf(session, key) { if (key === 'agentPreset') return 'dafeiyu'; if (key === 'tokenUsage') return { totals: { uncachedInputTokens: usage.get(session) || 0 } }; if (key === 'permissions') return permissionState.get(agents.find(a => a.session === session)?.id) } },
-  }
-  const ctx = { get: key => services[key], logger: { info() {} }, tools: { register: tool => tool }, settings: { describe: () => [] },
-    on(name, fn) { events.set(name, fn); return () => events.delete(name) },
-    effect(fn) { const c = fn(); if (typeof c === 'function') cleanup.push(c); return c },
-    webServer: { register(route) { handler = route.handler; return { dispose() {} } } },
-  }
-  const actualTimeout = globalThis.setTimeout, actualClearTimeout = globalThis.clearTimeout, actualInterval = globalThis.setInterval, actualClearInterval = globalThis.clearInterval
-  globalThis.setTimeout = (fn, ms) => { const timer = { fn, ms, cleared: false, unref() {} }; timeouts.push(timer); return timer }
-  globalThis.clearTimeout = timer => { if (timer) timer.cleared = true }
-  globalThis.setInterval = () => ({ unref() {} }); 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.killed = false
-    child.kill = () => { child.killed = true; return true }; children.push(child); return child
-  }; syncBuiltinESMExports()
-  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 = { headersSent: false, writableEnded: false, writeHead(code) { this.code = code; this.headersSent = true }, end(text) { this.body = JSON.parse(text); this.writableEnded = true } }
-    const result = handler(req, res)
-    if (method === 'POST') { req.emit('data', Buffer.from(JSON.stringify(body || {}))); req.emit('end') }
-    await result; return { code: res.code, ...res.body }
-  }
-  try {
-    apply(ctx, {})
-    await new Promise(resolve => setImmediate(resolve))
-    const created = await request('/pet/session-new', { sourceSessionId: b.id, workspaceId: workspace.id })
-    assert.equal(created.ok, true); assert.equal(created.sessionId, a.id); assert.equal(created.workspaceId, workspace.id)
-    assert.deepEqual(createRequests, [{ agentPreset: 'dafeiyu', workspaceId: workspace.id }])
-    assert.equal(created.permissions.sandbox, 'danger-full-access'); assert.equal(created.permissions.approval, 'never')
-    assert.ok(workspace.sessionIds.includes(a.id))
-    const started = await request('/pet/start', { mode: 'session', sessionId: a.id, model: 'explicit/session', tokenBudget: 100, maxRounds: 23, durationMinutes: 1 })
-    assert.equal(started.ok, true); assert.equal(started.maxRounds, 23); assert.equal(started.model, 'explicit/session')
-    assert.equal(started.tokenBudget, 100); assert.equal(started.durationEnforcement, 'wall-clock-pause')
-    const firstDeadline = timeouts.find(t => t.ms > 59000 && t.ms <= 60000)
-    assert.ok(firstDeadline)
-    let state = await request('/feiyu', {}, 'GET'); assert.equal(state.sessionId, a.id); assert.equal(state.tokens.budget, 100)
-    const saved = await request('/config', { backgroundModelId: 'other/background', backgroundTokenBudget: 4000, backgroundMinutes: 999 })
-    assert.equal(saved.config.backgroundMinutes, 180); assert.ok(saved.clamped.some(x => x.key === 'backgroundMinutes'))
-    assert.equal(saved.config.sessionModelId, 'saved/session'); assert.equal(saved.config.modelId, 'legacy/model')
-    state = await request('/feiyu', {}, 'GET'); assert.equal(state.tokens.budget, 100)
-    usage.set(a.session, 101); events.get('agent/status')({ agent: a, status: 'idle' })
-    const fuse = timeouts.findLast(t => t.ms === 1200); assert.ok(fuse); fuse.fn()
-    assert.equal(goals.get(a).phase, 'paused')
-    await request('/feiyu', { action: 'clear', sessionId: a.id })
-    const second = await request('/pet/start', { mode: 'session', sessionId: a.id, tokenBudget: 0, maxRounds: 7, durationMinutes: 2 })
-    assert.equal(second.ok, true); const secondGoal = goals.get(a).id
-    firstDeadline.fn(); fuse.fn(); assert.equal(goals.get(a).id, secondGoal); assert.equal(goals.get(a).phase, 'active', 'stale deadline and token timers must not pause new run')
-    await request('/pet/start', { mode: 'session', sessionId: b.id, tokenBudget: 0, durationMinutes: 0 })
-    await request('/feiyu', { action: 'stop', sessionId: a.id }); assert.equal(goals.get(a).phase, 'paused'); assert.equal(goals.get(b).phase, 'active')
-    const secondDeadline = timeouts.find(t => t.ms > 119000 && t.ms <= 120000)
-    await request('/feiyu', { action: 'resume', sessionId: a.id }); secondDeadline.fn(); assert.equal(goals.get(a).phase, 'paused', 'wall clock timer must work while agent is running with no tool events')
-    const blocked = await request('/pet/start', { mode: 'background', model: 'explicit/background', tokenBudget: 6000, durationMinutes: 3 })
-    assert.equal(blocked.started, false, 'session fish still swimming ⇒ background start must refuse (double-draw guard)')
-    await request('/feiyu', { action: 'stop', sessionId: b.id }); assert.equal(goals.get(b).phase, 'paused')
-    const bg = await request('/pet/start', { mode: 'background', model: 'explicit/background', tokenBudget: 6000, durationMinutes: 3 })
-    assert.equal(bg.started, true); assert.equal(bg.tokenBudgetEnforcement, 'advisory'); assert.equal(bg.backgroundRun.durationMinutes, 3)
-    assert.equal(spawned.length, 1); assert.match(spawned[0].args.at(-1), /6000/)
-    const overlay = readFileSync(join(home, 'headless-overlay.yml'), 'utf8'); assert.match(overlay, /provider: 'dafeiyu-parent'/); assert.match(overlay, /model: 'explicit\/background'/)
-    assert.match(overlay, /model-relay-adapter\.mjs/)
-    assert.doesNotMatch(overlay, /BILI_DUTY_RELAY_CAPABILITY/)
-    assert.match(spawned[0].opts.env.BILI_DUTY_RELAY_CAPABILITY, /^[a-f0-9]{64}$/)
-    const config = await request('/config', {}, 'GET'); assert.equal(config.config.modelId, 'legacy/model'); assert.equal(config.config.backgroundModelId, 'other/background')
-    assert.equal((await request('/feiyu', {}, 'GET')).sessionId, b.id, 'untargeted control prefers an active fish over paused sessions')
-    const stopped = await request('/pet/stop', {}); assert.equal(stopped.ok, true); assert.equal(children[0].killed, true); assert.equal(goals.get(b).phase, 'paused', 'pet/stop must not touch session fish')
-    assert.equal((await request('/pet/start', { mode: 'background' })).busy, true, 'do not overlap workers until actual exit')
-    const bgDeadline = timeouts.find(t => t.ms > 179000 && t.ms <= 180000); assert.ok(bgDeadline)
-    children[0].emit('close', null)
-    const again = await request('/pet/start', { mode: 'background', durationMinutes: 4 }); assert.ok(again.started)
-    bgDeadline.fn(); assert.equal(children[1].killed, false, 'old deadline cannot kill replacement background run')
-    const newDeadline = timeouts.find(t => t.ms > 239000 && t.ms <= 240000); assert.ok(newDeadline); newDeadline.fn(); assert.equal(children[1].killed, true)
-    children[1].emit('close', null)
-    assert.equal((await request('/status', {}, 'GET')).backgroundRun.stopReason, 'time-limit')
-    const logs = await request('/pet/log?n=500', {}, 'GET'); assert.ok(logs.entries.some(e => e.type === 'bg-done' && e.code === null && e.reason === 'user'))
-    assert.equal((await request('/pet/start', { mode: 'bad' })).code, 400)
-    assert.equal((await request('/pet/start', { mode: 'session' })).code, 400)
-    assert.equal((await request('/pet/start', { mode: 'session', sessionId: 'missing' })).ok, false)
-  } finally {
-    for (const fn of cleanup.reverse()) { try { fn() } catch {} }
-    globalThis.setTimeout = actualTimeout; globalThis.clearTimeout = actualClearTimeout; globalThis.setInterval = actualInterval; globalThis.clearInterval = actualClearInterval
-    cp.spawn = actualSpawn; syncBuiltinESMExports(); rmSync(root, { recursive: true, force: true })
-  }
-})

package/tests/pet-run-settings.test.mjs

@@ -1,38 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { migrateRunSettings, clampRunSettings, resolveRunOptions, scheduleRunDeadline } from '../lib/run-settings.mjs'
-
-test('legacy values only migrate missing mode keys', () => {
-  const migrated = migrateRunSettings({ modelId: 'old/model', tokenBudget: 120000, maxRounds: 12, sessionModelId: '', backgroundTokenBudget: 0 })
-  assert.equal(migrated.sessionModelId, '')
-  assert.equal(migrated.backgroundModelId, 'old/model')
-  assert.equal(migrated.sessionTokenBudget, 120000)
-  assert.equal(migrated.backgroundTokenBudget, 0)
-  assert.equal(migrated.sessionMaxRounds, 12)
-  assert.equal(migrated.backgroundMinutes, 45)
-})
-
-test('mode options remain independent and explicit rounds are not inferred from tokens', () => {
-  const cfg = { sessionModelId: 's/m', sessionTokenBudget: 10, sessionMaxRounds: 19, sessionMinutes: 0, backgroundModelId: 'b/m', backgroundTokenBudget: 90000, backgroundMinutes: 17 }
-  assert.deepEqual(resolveRunOptions(cfg, 'session', { tokenBudget: 5000000 }).maxRounds, 19)
-  const session = resolveRunOptions(cfg, 'session', { model: 'x/y', maxRounds: 7, durationMinutes: 20 })
-  assert.equal(session.model, 'x/y'); assert.equal(session.maxRounds, 7); assert.equal(session.tokenBudget, 10)
-  const bg = resolveRunOptions(cfg, 'background')
-  assert.equal(bg.model, 'b/m'); assert.equal(bg.durationMinutes, 17)
-  assert.equal(bg.tokenBudgetEnforcement, 'advisory'); assert.equal(bg.maxRoundsEnforcement, 'single-run')
-  assert.equal(cfg.sessionModelId, 's/m')
-})
-
-test('new config bounds clamp to documented integer ranges', () => {
-  assert.deepEqual(clampRunSettings({ sessionMinutes: -1, backgroundMinutes: 999, sessionMaxRounds: 2000, sessionTokenBudget: 9999999, backgroundTokenBudget: -1 }), { sessionMinutes: 0, backgroundMinutes: 180, sessionMaxRounds: 1000, sessionTokenBudget: 5000000, backgroundTokenBudget: 0 })
-})
-
-test('deadline timer works without a tool or idle event and is unreferenced', () => {
-  let callback, delay, unref = false, expired = false
-  const timer = { unref() { unref = true } }
-  const timers = { setTimeout(fn, ms) { callback = fn; delay = ms; return timer } }
-  assert.equal(scheduleRunDeadline(0, () => {}, timers), null)
-  assert.equal(scheduleRunDeadline(Date.now() + 5000, () => { expired = true }, timers), timer)
-  assert.ok(delay > 4000 && delay <= 5000); assert.ok(unref)
-  callback(); assert.ok(expired)
-})

package/tests/pet-session.test.mjs

@@ -1,125 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { createPetSession } from '../lib/pet-session.mjs'
-
-const cwd = 'D:\\鱼的工作区', otherCwd = 'D:\\另一个工作区'
-function fixture({ sourceMode = 'danger-full-access', sourceApproval = 'never', sourcePreset = 'danger-full-access', attached = true } = {}) {
-  const calls = [], setCalls = [], sessions = new Map(), agents = new Map()
-  const specs = { 'workspace-write': { sandbox: 'workspace-write', approval: 'ask' }, 'danger-full-access': { sandbox: 'danger-full-access', approval: 'never' }, auto: { sandbox: 'danger-full-access', approval: 'ask' } }
-  const makeSession = (id, path, sandbox, approval, preset) => {
-    const events = [], state = { sandbox, approval, preset }
-    const session = { id, header: { cwd: path }, events, state,
-      append(type, data) { events.push({ type, data }); if (type === 'sandbox/mode') state.sandbox = data.mode; if (type === 'approval/policy') state.approval = data.policy; if (type === 'permission/preset') state.preset = data.preset } }
-    sessions.set(id, session); agents.set(id, { id, session }); return session
-  }
-  const source = makeSession('source', cwd, sourceMode, sourceApproval, sourcePreset)
-  const workspace = { id: 'fish-workspace', path: cwd, sessionIds: attached ? ['source'] : [] }
-  const other = { id: 'other-workspace', path: otherCwd, sessionIds: [] }, workspaces = [workspace, other]
-  const services = {
-    agents: { get: id => agents.get(id) }, sessions: { get: id => sessions.get(id) },
-    workspaceRegistry: { get: id => workspaces.find(x => x.id === id), list: () => workspaces,
-      resolveByPath: async path => workspaces.find(x => x.path === path) },
-    sandboxPolicy: { resolve: ({ session }) => ({ mode: session.state.sandbox, workspaceRoot: session.header.cwd }) },
-    approval: { effectivePolicy: session => session.state.approval },
-    sessionProjections: { stateOf: session => session.state },
-    permissionPresets: {
-      current(session) { const state = session.state, spec = specs[state.preset]; return spec?.sandbox === state.sandbox && (spec.approval === state.approval || state.preset === 'auto' && state.approval === 'never') ? state.preset : Object.keys(specs).find(key => specs[key].sandbox === state.sandbox && specs[key].approval === state.approval) ?? 'custom' },
-      resolve: key => { if (!specs[key]) throw new Error('unknown preset'); return specs[key] },
-      set(session, preset) { setCalls.push({ session: session.id, preset }); const spec = specs[preset]; session.append('permission/preset', { preset }); session.append('sandbox/mode', { mode: spec.sandbox }); session.append('approval/policy', { policy: spec.approval }) },
-    },
-  }
-  const ctx = { get: key => services[key] }
-  const controller = {
-    async create(request) {
-      calls.push(request)
-      assert.deepEqual(Object.keys(request).sort(), ['agentPreset', request.workspaceId ? 'workspaceId' : 'cwd'].sort(), 'only actual Host SessionCreateRequest fields are forwarded')
-      assert.equal(request.agentPreset, 'dafeiyu')
-      const owner = services.workspaceRegistry?.get(request.workspaceId), path = owner?.path ?? request.cwd
-      const session = makeSession('created-' + calls.length, path, 'workspace-write', 'ask', 'workspace-write')
-      if (owner) owner.sessionIds.push(session.id)
-      return { sessionId: session.id, agentPreset: 'dafeiyu' }
-    },
-  }
-  return { ctx, controller, calls, setCalls, sessions, agents, services, source, workspace, workspaces }
-}
-
-test('pet session belongs to selected Workspace and inherits full access without changing defaults', async () => {
-  const f = fixture()
-  const result = await createPetSession(f.ctx, f.controller, { sourceSessionId: 'source', workspaceId: 'fish-workspace' }, { fallbackCwd: otherCwd })
-  assert.deepEqual(f.calls, [{ agentPreset: 'dafeiyu', workspaceId: 'fish-workspace' }])
-  assert.ok(f.workspace.sessionIds.includes(result.sessionId))
-  assert.equal(f.sessions.get(result.sessionId).header.cwd, cwd)
-  assert.deepEqual(result.permissions, { preset: 'danger-full-access', sandbox: 'danger-full-access', approval: 'never', inherited: true })
-  assert.deepEqual(f.setCalls, [{ session: result.sessionId, preset: 'danger-full-access' }])
-  assert.deepEqual(f.source.events, [], 'inheritance never modifies the source')
-})
-
-test('pet session infers ownership from source membership or canonical cwd, keeping restrictive permissions', async () => {
-  for (const attached of [true, false]) {
-    const f = fixture({ attached, sourceMode: 'workspace-write', sourceApproval: 'ask', sourcePreset: 'workspace-write' })
-    const result = await createPetSession(f.ctx, f.controller, { sourceSessionId: 'source', sandbox: 'danger-full-access', approval: 'never' })
-    assert.equal(f.calls[0].workspaceId, 'fish-workspace')
-    assert.equal(result.permissions.sandbox, 'workspace-write'); assert.equal(result.permissions.approval, 'ask')
-  }
-})
-
-test('pet session inherits custom sandbox/approval combination and delegated Auto never exactly', async () => {
-  for (const options of [
-    { sourceMode: 'read-only', sourceApproval: 'never', sourcePreset: 'custom' },
-    { sourceMode: 'danger-full-access', sourceApproval: 'never', sourcePreset: 'auto' },
-  ]) {
-    const f = fixture(options)
-    const result = await createPetSession(f.ctx, f.controller, { sourceSessionId: 'source' })
-    const target = f.sessions.get(result.sessionId)
-    assert.equal(result.permissions.sandbox, options.sourceMode); assert.equal(result.permissions.approval, options.sourceApproval)
-    assert.equal(f.setCalls.length, options.sourcePreset === 'auto' ? 1 : 0, 'Auto retains its identity and admission check; custom knobs have no selectable preset')
-    if (options.sourcePreset === 'auto') assert.equal(result.permissions.preset, 'auto')
-    assert.ok(target.events.some(x => x.type === 'sandbox/mode' && x.data.mode === options.sourceMode))
-    assert.ok(target.events.some(x => x.type === 'approval/policy' && x.data.policy === 'never'))
-    assert.ok(target.events.every(x => x.type !== 'permission/preset' || x.data.preset !== 'custom'))
-  }
-})
-
-test('pet session reads scoped effective permissions and can resolve a cold selected session', async () => {
-  const f = fixture({ sourceMode: 'read-only', sourceApproval: 'ask', sourcePreset: 'custom' })
-  const scoped = { ...f.services, sandboxPolicy: { resolve: () => ({ mode: 'danger-full-access' }) }, approval: { effectivePolicy: () => 'never' }, permissionPresets: { current: () => 'custom' } }
-  const agent = f.agents.get('source'); agent.ctx = { get: key => scoped[key] }
-  f.agents.delete('source'); f.sessions.delete('source')
-  f.controller.resolveAgent = async id => { assert.equal(id, 'source'); return { agent } }
-  const result = await createPetSession(f.ctx, f.controller, { sourceSessionId: 'source' })
-  assert.equal(result.permissions.sandbox, 'danger-full-access'); assert.equal(result.permissions.approval, 'never')
-})
-
-test('pet session context errors do not silently create a stray session', async () => {
-  for (const body of [{ sourceSessionId: 'missing' }, { workspaceId: 'missing' }, { sourceSessionId: 'source', workspaceId: 'other-workspace' }, { sourceSessionId: {} }]) {
-    const f = fixture()
-    await assert.rejects(createPetSession(f.ctx, f.controller, body))
-    assert.equal(f.calls.length, 0)
-  }
-  const f = fixture()
-  await assert.rejects(createPetSession(f.ctx, f.controller, {}, { fallbackCwd: 'D:\\unowned' }), /无法确定当前工作区/)
-  assert.equal(f.calls.length, 0)
-})
-
-test('legacy pet request uses matching directory or sole Workspace and retains Host defaults', async () => {
-  const f = fixture()
-  const matched = await createPetSession(f.ctx, f.controller, {}, { fallbackCwd: cwd })
-  assert.equal(matched.workspaceId, 'fish-workspace'); assert.equal(matched.permissions.inherited, false)
-  assert.equal(matched.permissions.sandbox, 'workspace-write')
-  f.workspaces.splice(1)
-  const single = await createPetSession(f.ctx, f.controller, {}, { fallbackCwd: otherCwd })
-  assert.equal(single.workspaceId, 'fish-workspace')
-  f.services.workspaceRegistry = undefined
-  const withoutRegistry = await createPetSession(f.ctx, f.controller, { sourceSessionId: 'source' })
-  assert.deepEqual(f.calls.at(-1), { agentPreset: 'dafeiyu', cwd })
-  assert.equal(withoutRegistry.permissions.sandbox, 'danger-full-access')
-})
-
-test('permission inheritance failure returns created identity and cannot be mistaken for a startable success', async () => {
-  const f = fixture()
-  f.services.permissionPresets.set = () => {}
-  f.services.sandboxPolicy = { resolve: ({ session }) => ({ mode: session.id === 'source' ? 'danger-full-access' : 'workspace-write' }) }
-  await assert.rejects(createPetSession(f.ctx, f.controller, { sourceSessionId: 'source' }), error => {
-    assert.equal(error.sessionId, 'created-1'); assert.match(error.message, /权限继承未生效/); return true
-  })
-})