@mzzsfy/dsh-keep-working 0.0.0-stage → 0.2.0

package/test/engine.test.mjs

@@ -0,0 +1,436 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { resolveConfig } from '../src/config.mjs'
+import { createEngine } from '../src/engine.mjs'
+
+const TURN = 1
+const START_TIME = 1_000_000
+
+const event = (seq, type, data) => ({ seq, time: seq, type, data })
+
+const turnStart = (seq, turn, reason) =>
+  event(seq, 'turn/start', reason === undefined ? { turn } : { turn, reason })
+
+const turnEnd = (seq, turn, reason) => event(seq, 'turn/end', { turn, reason })
+
+const assistant = (seq, turn, text) =>
+  event(seq, 'assistant/message', {
+    turn,
+    step: 1,
+    message: { role: 'assistant', content: [{ type: 'text', text }] },
+    stream: [],
+  })
+
+const toolCall = (seq, turn, name) =>
+  event(seq, 'tool/call', { turn, step: 1, callId: `c-${seq}`, name, arguments: '{}' })
+
+const presented = (seq, turn) =>
+  event(seq, 'deliverables/presented', { turn, callId: `c-${seq}`, files: [{ path: 'out.md' }] })
+
+const userMessage = (seq, kind = 'user', id = `m-${seq}`) =>
+  event(seq, 'user/message', { id, source: { kind }, content: [{ type: 'text', text: 'go' }] })
+
+function createFakeTimers(clock) {
+  let next = 0
+  const pending = new Map()
+  return {
+    setTimeout(fn, ms) {
+      const id = (next += 1)
+      pending.set(id, { fn, at: clock() + ms })
+      return id
+    },
+    clearTimeout(id) {
+      pending.delete(id)
+    },
+    flush() {
+      const jobs = [...pending.entries()].sort((left, right) => left[1].at - right[1].at)
+      pending.clear()
+      for (const [, job] of jobs) job.fn()
+    },
+    count: () => pending.size,
+  }
+}
+
+function createHarness({ origin, header, config: overrides, probe } = {}) {
+  let time = START_TIME
+  const events = []
+  const sent = []
+  const handlers = new Map()
+  const timers = createFakeTimers(() => time)
+  const session = { id: 's1', header: header ?? (origin === undefined ? {} : { origin }), snapshotEvents: () => events }
+  const agent = {
+    id: 's1',
+    session,
+    inbox: { nextTurn: [] },
+    followup: (message) => sent.push(message),
+  }
+  const ctx = {
+    agents: {
+      get: (id) => (id === 's1' ? agent : undefined),
+      list: () => [agent],
+    },
+    logger: { info() {}, warn() {} },
+    on: (name, handler) => {
+      handlers.set(name, handler)
+      return () => handlers.delete(name)
+    },
+  }
+  const engine = createEngine({
+    ctx,
+    config: resolveConfig(overrides),
+    timers,
+    now: () => time,
+    createUserMessage: (options) => ({ id: `auto-${sent.length + 1}`, ...options }),
+    probe,
+  })
+  engine.attach()
+  const emit = (item) => {
+    events.push(item)
+    handlers.get('session/event')?.(session, item)
+  }
+  // 插件 followup 启动的回合,首条 user/message 就是它投递的那条;
+  // 夹具按真实事件序复用它,human=true 才模拟真人新回合
+  const runTurn = (seq, turn, text = '没结案', { human = false } = {}) => {
+    emit(turnStart(seq, turn))
+    const lastId = sent.at(-1)?.id
+    emit(userMessage(seq + 1, 'user', human || lastId === undefined ? `m-${seq + 1}` : lastId))
+    emit(assistant(seq + 2, turn, text))
+    emit(turnEnd(seq + 3, turn, { kind: 'completed' }))
+    timers.flush()
+  }
+  return {
+    engine,
+    emit,
+    sent,
+    timers,
+    runTurn,
+    session,
+    advanceTo: (value) => {
+      time = value
+    },
+    now: () => time,
+  }
+}
+
+const textOf = (message) => message.content.map((block) => block.text).join('')
+
+test('S1 有文件写入且无 present:登记一次并发送结案提醒', () => {
+  const h = createHarness()
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(toolCall(2, TURN, 'write'))
+  h.emit(assistant(3, TURN, '改好了'))
+  h.emit(turnEnd(4, TURN, { kind: 'completed' }))
+  assert.equal(h.timers.count(), 1)
+  h.timers.flush()
+  assert.equal(h.sent.length, 1)
+  assert.match(textOf(h.sent[0]), /TASK_DONE/)
+})
+
+test('S2 末行 TASK_DONE:不发送', () => {
+  const h = createHarness()
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(assistant(2, TURN, '结论\nTASK_DONE'))
+  h.emit(turnEnd(3, TURN, { kind: 'completed' }))
+  assert.equal(h.timers.count(), 0)
+  h.timers.flush()
+  assert.equal(h.sent.length, 0)
+})
+
+test('S3 子会话:不发送', () => {
+  const h = createHarness({ origin: 'subagent' })
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(assistant(2, TURN, '没结案'))
+  h.emit(turnEnd(3, TURN, { kind: 'completed' }))
+  assert.equal(h.timers.count(), 0)
+})
+
+test('S3b 旧格式子会话(parentSession + delegationDepth):不发送;普通 fork 照常', () => {
+  for (const header of [
+    { parentSession: 'root', delegationDepth: 1 },
+    { parentSession: 'root', delegationDepth: 2 },
+  ]) {
+    const h = createHarness({ header })
+    h.emit(turnStart(0, TURN))
+    h.emit(userMessage(1))
+    h.emit(assistant(2, TURN, '没结案'))
+    h.emit(turnEnd(3, TURN, { kind: 'completed' }))
+    assert.equal(h.timers.count(), 0)
+  }
+  const fork = createHarness({ header: { parentSession: 'root', delegationDepth: 0 } })
+  fork.emit(turnStart(0, TURN))
+  fork.emit(userMessage(1))
+  fork.emit(assistant(2, TURN, '没结案'))
+  fork.emit(turnEnd(3, TURN, { kind: 'completed' }))
+  assert.ok(fork.timers.count() > 0, 'depth 0 是普通 fork,不得按子会话跳过')
+})
+
+test('S4 连续上限:达到 maxConsecutive 后不再发送', () => {
+  const h = createHarness({ config: { maxConsecutive: 2 } })
+  // 回合号必须逐轮递增:turnSlice 按首个匹配回合切片,复用 id 会读到上一轮事件
+  const run = (seq, turn) => h.runTurn(seq, turn)
+  run(0, 1)
+  assert.equal(h.sent.length, 1)
+  h.advanceTo(h.now() + 60_000)
+  run(10, 2)
+  assert.equal(h.sent.length, 2)
+  h.advanceTo(h.now() + 600_000)
+  run(20, 3)
+  assert.equal(h.sent.length, 2)
+})
+
+test('S4b 正常结案清零连续计数:封顶后仍可再次恢复', () => {
+  const h = createHarness({ config: { maxConsecutive: 2 } })
+  const run = (seq, turn, text = '没结案') => h.runTurn(seq, turn, text)
+  run(0, 1)
+  h.advanceTo(h.now() + 60_000)
+  run(10, 2)
+  assert.equal(h.sent.length, 2)
+  h.advanceTo(h.now() + 600_000)
+  run(20, 3)
+  assert.equal(h.sent.length, 2, '达到上限后不再发送')
+  run(30, 4, '结论\nTASK_DONE')
+  assert.equal(h.sent.length, 2, '结案本身不发送')
+  h.advanceTo(h.now() + 600_000)
+  run(40, 5)
+  assert.equal(h.sent.length, 3, '结案已清零计数,下一轮重新获得额度')
+})
+
+test('S4c 封顶后用户重新发起回合:额度恢复', () => {
+  const h = createHarness({ config: { maxConsecutive: 1 } })
+  const run = (seq, turn) => h.runTurn(seq, turn)
+  run(0, 1)
+  assert.equal(h.sent.length, 1)
+  h.advanceTo(h.now() + 60_000)
+  run(10, 2)
+  assert.equal(h.sent.length, 1, '插件自己 followup 启动的回合不得重置')
+  // 封顶后用户手动开新回合:没有待消费的插件回合,视为接管
+  h.runTurn(20, 3, '没结案', { human: true })
+  assert.equal(h.sent.length, 2, '用户接管后恢复一次额度')
+})
+
+test('S4d 自投递回合未真正开始:用户回合仍恢复额度', () => {
+  const h = createHarness({ config: { maxConsecutive: 1 } })
+  h.runTurn(0, 1)
+  assert.equal(h.sent.length, 1)
+  // followup 被宿主吞掉、没有新回合:下一轮真人回合不得被当成插件自己的回合
+  h.advanceTo(h.now() + 600_000)
+  h.runTurn(10, 2, '没结案', { human: true })
+  assert.equal(h.sent.length, 2)
+})
+
+test('S5 用户中途插话:让路,不发送', () => {
+  const h = createHarness()
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(assistant(2, TURN, '先看看'))
+  h.emit(userMessage(3, 'user'))
+  h.emit(assistant(4, TURN, '好的'))
+  h.emit(turnEnd(5, TURN, { kind: 'completed' }))
+  assert.equal(h.timers.count(), 0)
+})
+
+test('S5b 用户插话且回合无可见输出:让路,不发静默补发', () => {
+  const h = createHarness()
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(toolCall(2, TURN, 'read'))
+  h.emit(userMessage(3, 'user'))
+  h.emit(turnEnd(4, TURN, { kind: 'completed' }))
+  assert.equal(h.timers.count(), 0)
+})
+
+test('S6 可重试错误:发送继续文案', () => {
+  const h = createHarness()
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(turnEnd(2, TURN, { kind: 'error', error: { code: 'UPSTREAM', message: 'bad gateway', status: 502 } }))
+  h.timers.flush()
+  assert.equal(h.sent.length, 1)
+  assert.match(textOf(h.sent[0]), /结果未知/)
+})
+
+test('S7 永久错误:不发送', () => {
+  const h = createHarness()
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(turnEnd(2, TURN, { kind: 'error', error: { code: 'AUTH', message: 'invalid api key' } }))
+  assert.equal(h.timers.count(), 0)
+})
+
+test('S8 max-tokens:发送截断文案', () => {
+  const h = createHarness()
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(turnEnd(2, TURN, { kind: 'max-tokens' }))
+  h.timers.flush()
+  assert.equal(h.sent.length, 1)
+  assert.match(textOf(h.sent[0]), /输出上限/)
+})
+
+test('S9 interrupted:发送重启文案', () => {
+  const h = createHarness()
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(turnEnd(2, TURN, { kind: 'interrupted' }))
+  h.timers.flush()
+  assert.equal(h.sent.length, 1)
+  assert.match(textOf(h.sent[0]), /结果未知/)
+})
+
+test('S10 用户取消:不发送', () => {
+  const h = createHarness()
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(turnEnd(2, TURN, { kind: 'aborted', reason: { kind: 'user' } }))
+  assert.equal(h.timers.count(), 0)
+})
+
+test('S11 宿主重启取消:按 interrupted 恢复', () => {
+  const h = createHarness()
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(turnEnd(2, TURN, { kind: 'aborted', reason: { kind: 'disposed' } }))
+  h.timers.flush()
+  assert.equal(h.sent.length, 1)
+})
+
+test('S12 维护轮:不发送', () => {
+  const h = createHarness()
+  h.emit(turnStart(0, TURN, 'message-ops'))
+  h.emit(assistant(1, TURN, '压缩完成'))
+  h.emit(turnEnd(2, TURN, { kind: 'completed' }))
+  assert.equal(h.timers.count(), 0)
+})
+
+test('S13 宽限期内开启新回合:取消待发送', () => {
+  const h = createHarness()
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(assistant(2, TURN, '没结案'))
+  h.emit(turnEnd(3, TURN, { kind: 'completed' }))
+  assert.equal(h.timers.count(), 1)
+  h.emit(turnStart(4, TURN + 1))
+  assert.equal(h.timers.count(), 0)
+})
+
+test('S14 非用户发起回合:不发送结案提醒', () => {
+  const h = createHarness()
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1, 'goal'))
+  h.emit(assistant(2, TURN, '没结案'))
+  h.emit(turnEnd(3, TURN, { kind: 'completed' }))
+  assert.equal(h.timers.count(), 0)
+})
+
+test('S15 无可见输出的回合:发送 silent 文案', () => {
+  const h = createHarness()
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(turnEnd(2, TURN, { kind: 'completed' }))
+  h.timers.flush()
+  assert.equal(h.sent.length, 1)
+  assert.match(textOf(h.sent[0]), /没有可见输出/)
+})
+
+test('S17 present 之后又写文件:仍需提醒', () => {
+  const h = createHarness()
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(toolCall(2, TURN, 'write'))
+  h.emit(presented(3, TURN))
+  h.emit(toolCall(4, TURN, 'edit'))
+  h.emit(assistant(5, TURN, '又改了'))
+  h.emit(turnEnd(6, TURN, { kind: 'completed' }))
+  assert.equal(h.timers.count(), 1)
+  h.timers.flush()
+  assert.equal(h.sent.length, 1)
+})
+
+test('S16 自己发出的消息不算用户接管', () => {
+  const h = createHarness()
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(assistant(2, TURN, '没结案'))
+  h.emit(turnEnd(3, TURN, { kind: 'completed' }))
+  h.timers.flush()
+  const autoId = h.sent[0].id
+
+  h.advanceTo(h.now() + 60_000)
+  h.emit(turnStart(4, TURN + 1))
+  h.emit(userMessage(5, 'user', autoId))
+  h.emit(assistant(6, TURN + 1, '仍然没结案'))
+  h.emit(turnEnd(7, TURN + 1, { kind: 'completed' }))
+  h.timers.flush()
+  assert.equal(h.sent.length, 2)
+})
+
+test('卸载后不再响应事件', () => {
+  const h = createHarness()
+  h.engine.dispose()
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(turnEnd(2, TURN, { kind: 'max-tokens' }))
+  assert.equal(h.timers.count(), 0)
+})
+
+test('离线时挂起,联网后补发', async () => {
+  let online = false
+  const h = createHarness({ probe: async () => online })
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(turnEnd(2, TURN, { kind: 'max-tokens' }))
+  h.timers.flush()
+  await new Promise((resolve) => setImmediate(resolve))
+  assert.equal(h.sent.length, 0)
+  assert.equal(h.timers.count(), 1)
+
+  online = true
+  h.timers.flush()
+  await new Promise((resolve) => setImmediate(resolve))
+  assert.equal(h.sent.length, 1)
+})
+
+test('离线探测抛错时按在线处理', async () => {
+  const h = createHarness({
+    probe: async () => {
+      throw new Error('probe failed')
+    },
+  })
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(turnEnd(2, TURN, { kind: 'max-tokens' }))
+  h.timers.flush()
+  await new Promise((resolve) => setImmediate(resolve))
+  assert.equal(h.sent.length, 1)
+})
+
+test('S18 插件补发的回合里用户插话一条:让路', () => {
+  const h = createHarness({ config: { maxConsecutive: 5 } })
+  h.runTurn(0, 1, '没结案', { human: true })
+  assert.equal(h.sent.length, 1)
+  h.advanceTo(h.now() + 60_000)
+  // 第二回合由 auto-1 发起,真人随后插了一条
+  const autoId = h.sent.at(-1).id
+  h.emit(turnStart(10, 2))
+  h.emit(userMessage(11, 'user', autoId))
+  h.emit(userMessage(12, 'user', 'm-12'))
+  h.emit(assistant(13, 2, '没结案'))
+  h.emit(turnEnd(14, 2, { kind: 'completed' }))
+  h.timers.flush()
+  assert.equal(h.sent.length, 1, '插件回合内的真人插话必须让路')
+})
+
+test('S19 空回合开关关闭但有有效写入:仍要求 present', () => {
+  const h = createHarness({ config: { resumeSilentTurns: false } })
+  h.emit(turnStart(0, TURN))
+  h.emit(userMessage(1))
+  h.emit(toolCall(2, TURN, 'write'))
+  h.emit(turnEnd(4, TURN, { kind: 'completed' }))
+  h.timers.flush()
+  assert.equal(h.sent.length, 1, '文件已改就不能被空回合开关跳过')
+  assert.match(textOf(h.sent[0]), /TASK_DONE/)
+})

package/test/failure.test.mjs

@@ -0,0 +1,81 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  isTransientFailure,
+  parseFailureFacts,
+} from '../src/failure.mjs'
+
+const facts = (code, message, status) =>
+  status === undefined ? { code, message } : { code, message, status }
+
+test('parseFailureFacts 只接受可解释的失败载荷', () => {
+  assert.deepEqual(parseFailureFacts({ code: 'UPSTREAM', message: 'boom', status: 502 }), {
+    code: 'UPSTREAM',
+    message: 'boom',
+    status: 502,
+  })
+  assert.deepEqual(parseFailureFacts({ message: '只有描述' }), { code: 'UNKNOWN', message: '只有描述' })
+  assert.equal(parseFailureFacts(undefined), undefined)
+  assert.equal(parseFailureFacts(null), undefined)
+  assert.equal(parseFailureFacts('boom'), undefined)
+  assert.equal(parseFailureFacts({}), undefined)
+})
+
+test('鉴权与权限失败属永久错误', () => {
+  assert.equal(isTransientFailure(facts('UNAUTHORIZED', 'invalid api key')), false)
+  assert.equal(isTransientFailure(facts('UPSTREAM', 'forbidden', 403)), false)
+  assert.equal(isTransientFailure(facts('UPSTREAM', 'something', 401)), false)
+})
+
+test('余额与配额耗尽属永久错误', () => {
+  assert.equal(isTransientFailure(facts('BILLING', 'insufficient balance')), false)
+  assert.equal(isTransientFailure(facts('QUOTA', 'insufficient quota for this account')), false)
+})
+
+test('模型不存在与上下文超限属永久错误', () => {
+  assert.equal(isTransientFailure(facts('UPSTREAM', 'model not found: foo')), false)
+  assert.equal(isTransientFailure(facts('UPSTREAM', 'context length exceeded')), false)
+})
+
+test('网络、超时、5xx、429 属临时错误', () => {
+  assert.equal(isTransientFailure(facts('UPSTREAM', 'bad gateway', 502)), true)
+  assert.equal(isTransientFailure(facts('RATE_LIMIT', 'rate limit exceeded', 429)), true)
+  assert.equal(isTransientFailure(facts('TIMEOUT', 'request timed out')), true)
+})
+
+test('MALFORMED_RESPONSE 虽含关键词仍按临时处理', () => {
+  assert.equal(isTransientFailure(facts('MALFORMED_RESPONSE', 'tool echoed {api_key}')), true)
+})
+
+test('宿主把状态并进 message 时仍识别 401/403', () => {
+  assert.equal(isTransientFailure(facts('AUTH', '401 {"error":{"status":401}}')), false)
+  assert.equal(isTransientFailure(facts('UNKNOWN', 'upstream replied 403 forbidden')), false)
+  assert.equal(isTransientFailure(facts('UPSTREAM', 'bad gateway 502')), true)
+})
+
+test('AUTH 码单独出现即为永久', () => {
+  assert.equal(isTransientFailure(facts('AUTH', 'credentials rejected')), false)
+})
+
+test('用户自定义片段优先于内置判定', () => {
+  assert.equal(isTransientFailure(facts('UPSTREAM', 'invalid api key'), 'invalid api key'), true)
+  assert.equal(isTransientFailure(facts('UPSTREAM', 'bad gateway', 502), 'bad gateway'), true)
+})
+
+test('规范码判永久,不看中性描述', () => {
+  for (const code of ['QUOTA', 'ACCOUNT_QUOTA', 'NO_ADAPTER', 'INVALID_ARGS', 'AUTH', 'CONTEXT_WINDOW_EXCEEDED']) {
+    assert.equal(isTransientFailure({ code, message: 'the request failed' }), false, `${code} 应判永久`)
+  }
+})
+
+test('中性描述的额度原文不被当临时错误', () => {
+  const samples = [
+    'Resource has been exhausted (e.g. check quota).',
+    'Your credit balance is too low to access the Anthropic API',
+  ]
+  for (const message of samples) {
+    assert.equal(isTransientFailure({ code: 'QUOTA', message }), false, message)
+    assert.equal(isTransientFailure({ code: 'UNKNOWN', message }), false, `无规范码时也要按文本拦下: ${message}`)
+  }
+})

package/test/offline.test.mjs

@@ -0,0 +1,85 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  createConnectivityProbe,
+  hasExternalInterface,
+  usesExplicitProxy,
+} from '../src/offline.mjs'
+
+const interfacesOf = (entries) => () => entries
+
+test('无外部网卡时判定离线', () => {
+  assert.equal(hasExternalInterface(interfacesOf({})), false)
+  assert.equal(hasExternalInterface(interfacesOf({ lo: [{ internal: true, family: 'IPv4' }] })), false)
+  assert.equal(
+    hasExternalInterface(interfacesOf({ eth0: [{ internal: false, family: 'IPv4' }] })),
+    true,
+  )
+})
+
+test('读不到网卡信息时放行,不误判离线', () => {
+  assert.equal(
+    hasExternalInterface(() => {
+      throw new Error('boom')
+    }),
+    true,
+  )
+})
+
+test('显式代理存在时不依赖本地 DNS', () => {
+  assert.equal(usesExplicitProxy({ HTTPS_PROXY: 'http://127.0.0.1:7890' }), true)
+  assert.equal(usesExplicitProxy({ https_proxy: 'http://127.0.0.1:7890' }), true)
+  assert.equal(usesExplicitProxy({ HTTPS_PROXY: '   ' }), false)
+  assert.equal(usesExplicitProxy({}), false)
+})
+
+test('任一探测主机可解析即在线', async () => {
+  const probe = createConnectivityProbe({
+    interfaces: interfacesOf({ eth0: [{ internal: false }] }),
+    env: {},
+    hosts: ['a.invalid', 'b.invalid'],
+    lookup: async (host) => {
+      if (host === 'b.invalid') return { address: '127.0.0.1' }
+      throw new Error('ENOTFOUND')
+    },
+  })
+  assert.equal(await probe(), true)
+})
+
+test('全部探测主机不可解析即离线', async () => {
+  const probe = createConnectivityProbe({
+    interfaces: interfacesOf({ eth0: [{ internal: false }] }),
+    env: {},
+    hosts: ['a.invalid', 'b.invalid'],
+    lookup: async () => {
+      throw new Error('ENOTFOUND')
+    },
+  })
+  assert.equal(await probe(), false)
+})
+
+test('探测失败不 reject,一律折算为在线或离线', async () => {
+  const probe = createConnectivityProbe({
+    interfaces: interfacesOf({ eth0: [{ internal: false }] }),
+    env: {},
+    hosts: ['a.invalid'],
+    lookup: () => Promise.reject(new Error('boom')),
+  })
+  assert.equal(await probe(), false)
+})
+
+test('无外部网卡时短路,不触发 DNS', async () => {
+  let called = false
+  const probe = createConnectivityProbe({
+    interfaces: interfacesOf({ lo: [{ internal: true }] }),
+    env: {},
+    hosts: ['a.invalid'],
+    lookup: async () => {
+      called = true
+      return { address: '127.0.0.1' }
+    },
+  })
+  assert.equal(await probe(), false)
+  assert.equal(called, false)
+})

package/test/prompt-section.test.mjs

@@ -0,0 +1,32 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { DEFAULTS } from '../src/config.mjs'
+import { PROMPT_TEXT, SECTION_NAME, buildSection } from '../src/index.js'
+
+/** 宿主文件引用段的真实位置,取自 dsh-system-prompt 的 SECTION_ORDERS。 */
+const FILE_REFERENCE_ORDER = 900
+
+const systemPrompt = { getSectionOrder: () => FILE_REFERENCE_ORDER }
+
+test('结案段落排在文件引用建议之后', () => {
+  const section = buildSection(systemPrompt)
+  assert.equal(section.name, SECTION_NAME)
+  assert.ok(section.order > FILE_REFERENCE_ORDER, '结案规则必须压在被覆盖的建议之后')
+})
+
+test('结案段落保留显式提交要求', () => {
+  for (const marker of ['TASK_DONE', 'TASK_BLOCKED: 原因', 'present']) {
+    assert.ok(PROMPT_TEXT.includes(marker), `缺少 ${marker}`)
+  }
+})
+
+test('结案段落声明 present 时机不受文件引用建议约束', () => {
+  assert.ok(PROMPT_TEXT.includes('present 的时机以本段为准'))
+})
+
+test('默认结案提醒与新标记一致', () => {
+  for (const marker of ['TASK_DONE', 'TASK_BLOCKED: 原因']) {
+    assert.ok(DEFAULTS.closureText.includes(marker), `缺少 ${marker}`)
+  }
+})

package/test/route-gate.test.mjs

@@ -0,0 +1,57 @@
+// 宿主闸门:插件路由必须回问 connection,未认证请求不得进业务面
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { rejectUnadmitted, withHostGate } from '../src/route-gate.mjs'
+
+function ctxWith(connection) {
+  return { get: (name) => (name === 'connection' ? connection : undefined) }
+}
+
+function makeRes() {
+  const res = { status: null, body: null, headers: null, ended: false }
+  res.writeHead = (status, headers) => {
+    res.status = status
+    res.headers = headers
+  }
+  res.end = (body) => {
+    res.ended = true
+    res.body = body
+  }
+  return res
+}
+
+test('G1 无 connection 服务时放行', () => {
+  const res = makeRes()
+  assert.equal(rejectUnadmitted(ctxWith(undefined), { headers: {} }, res), false)
+  assert.equal(res.ended, false)
+})
+
+test('G2 宿主拒绝时按状态码回纯文本', () => {
+  for (const [status, text] of [[401, 'unauthorized'], [403, 'forbidden']]) {
+    const res = makeRes()
+    assert.equal(rejectUnadmitted(ctxWith({ requestRejection: () => status }), { headers: {} }, res), true)
+    assert.equal(res.status, status)
+    assert.equal(res.body, text)
+  }
+})
+
+test('G3 闸门抛错按拒绝处理,不把故障当认证通过', () => {
+  const res = makeRes()
+  const ctx = ctxWith({ requestRejection: () => { throw new Error('boom') } })
+  assert.equal(rejectUnadmitted(ctx, { headers: {} }, res), true)
+  assert.equal(res.status, 403)
+})
+
+test('G4 withHostGate 拒绝时业务不执行,放行时透传', async () => {
+  let called = 0
+  const blocked = withHostGate(ctxWith({ requestRejection: () => 401 }), async () => { called += 1 })
+  await blocked({ headers: {} }, makeRes())
+  assert.equal(called, 0)
+  const seen = []
+  const pass = withHostGate(ctxWith(undefined), async (req, res) => { seen.push(req, res) })
+  const req = { headers: {} }
+  const res = makeRes()
+  await pass(req, res)
+  assert.deepEqual(seen, [req, res])
+})