@rezti/dsh-rez-task-handoff 0.0.0-stage → 0.1.0-beta.2

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2026 ReZ-TI / dsh-rez-suite contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -1,3 +1,63 @@
-# Temporary Holding Version
+# Jarvis 跨会话任务交接（模拟版 0.1.0-beta.2）
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+适用目标：DeepSeek Harness 桌面版，宿主 0.2.1-rc.5，Aurabot 1.1.24，desktop profile。只接受成功、失败、超时、需要确认四种模拟任务。没有 HA、摄像头、真实设备、系统命令或任意任务执行入口。不依赖或改动 RezSuite。
+
+## 从 npm 下载并检查
+
+这是通过 npm 分发的 **Aurabot 用户模块**。以下命令下载已发布的 beta.1。测试 beta.2 本地包时，把对应的压缩包解压到临时目录即可。
+
+```bash
+cd "$(mktemp -d)"
+npm pack @rezti/dsh-rez-task-handoff@0.1.0-beta.1 --ignore-scripts --registry https://registry.npmjs.org
+tar -xzf rezti-dsh-rez-task-handoff-0.1.0-beta.1.tgz
+node package/inspect.mjs
+```
+
+使用非默认目录时，可以向检查脚本依次传入 DSH 数据目录、应用路径。脚本只输出版本和存在性信息；应用安装版本、进程存在、profile 安装状态和实际激活是不同事实。再从桌面版插件面板核对实际启用状态，从 Jarvis 专用会话复制完整 ID。若还没有会话，请创建一个专用于模拟测试的会话。扩展使用固定 ID，不按名称搜索。
+
+## 接口与取舍
+
+- [Aurabot 1.1.24 用户模块 API](https://github.com/aureth-labs/dsh-aurabot-qq/blob/v1.1.24/src/modules/API.md)：使用 API v1 的 `tool`、`defineTool`、`prompt`、`rule`、`settings`、`isOwner`、`dataDir`、`every` 和卸载回调。用户模块目录与插件安装目录分离，升级保留；本扩展检测到其他 Aurabot 版本会停用，待核对再放开。
+- 从 1.1.24 源码验证，Aurabot 在 QQ agent 的 `agent.ctx.tools` 上挂模块工具。“纯聊天”档不挂模块工具，需要已有的支持工具档位。本模块同时核对配置的主人、原私聊 ID、实际执行会话和最新入站消息的可信标记。主人私聊的普通消息可查状态，提交须明确发送「让 Jarvis 做交接测试 success」或指定其他模拟模式。群聊、其他私聊、后台轮、DSH 直接输入、回传轮都不能触发。
+- DSH 0.2.1-rc.5 发行包已验证 `agents.get`、`Agent.followup`、`session/event`、`ToolRuntime.restrict/guard` 与 `exec.concludeTurn()`。用固定的完整会话 ID 定位已打开的 Jarvis。用唯一输入消息 ID 关联 `user/message` 与对应 `turn/end`，且只有模拟工具的结果可成为任务结果。`whenIdle()` 只用于清理；它不是具体任务的完成回执。测试运行时实际装载了同版本 AgentLoop。
+- 回传使用原 QQ Agent 的原生 follow-up。Aurabot 的聊天中枢会监听原会话事件并发送普通回复。以 `hub.sessions()`、`chatOfSession()` 做最后校验，映射变更、Agent 不在、主人静音时先等；通知最多等待十分钟。本机发布代码与真实核心的隔离测试证明这条路径成立。Aurabot 的 hub 映射和自动转发是版本相关的实现，未宣称跨版本稳定。没有采用 `api.think`：它会走后台会话。
+- [dsh-peer-bus](https://github.com/ybh1291747665/dsh-peer-bus) 和 [dsh-cross-session-agent](https://github.com/dd2673/dsh-cross-session-agent) 有成熟的会话间寻址、投递思路，但不能直接提供这里要求的 Aurabot 主人私聊作用域、模拟业务结果与原 QQ 回传闭环。这里复用原生 follow-up，不另造通信协议或引入跨进程桥。
+
+## 数据和状态
+
+`module/index.mjs` 是独立用户模块；`module/ledger.mjs` 保存独立账本。任务含唯一 ID、来源 QQ 对话和 DSH 会话 ID、固定目标 ID、模拟类型、时间、结果和每次回传记录。文件通过临时文件、同步与改名提交；权限 0600。不保存聊天正文、不读取 Aurabot 的整份配置、不接触凭据。单 desktop 宿主运行，不应让多个进程共享同一账本。
+
+- 接收：`queued` 表示本地账本已接收；确认后也会重新进入队列。
+- 执行：`running`、`completed`、`failed`、`timed_out`、`needs_confirmation`、`interrupted`。只有同一模拟任务的工具结果和匹配的正常轮次结束才算完成。确认须由同一主人在原私聊发出完整的 `确认交接 <任务 ID>`，十分钟内有效。此确认仅用于模拟流程。
+- 回传：待投递、已提交原会话、原会话已生成回复、结果不明、关闭回传或过期。正常回复链路没有供模块使用的 QQ 发送回执；**生成回复不代表 QQ 已发送，更不代表对方已读**。结果不明不自动补发。可在主人私聊询问「查交接 <任务 ID>」；这是最小的取回方式，不冒险另外发一条重复通知。
+- 同一模型输入重试提交复用任务 ID；同一模拟步骤持久化领取后只能执行一次；通知先写入投递记录再提交。进程或模块中断后，未结束的任务记为中断，不自动重跑；已提交/结果不明的通知不重发。已经排入 DSH inbox 的消息属于 DSH，无法撤回。暂不支持跨进程、冷 Jarvis 自动恢复、真实 QQ 回执或 OneBot 入口去重保证。
+- Jarvis 试验轮只暴露一个无害模拟工具。使用 DSH 的临时限制屏蔽继承的工具，工具守卫拒绝其他工具调用。对于从预设继承的 PTC，试验轮用 `presentAs('native')` 临时以原生方式呈现工具，轮次结束后撤销。如果存在无法切换的 PTC 声明或无法屏蔽的会话本地工具，任务会在投递前失败。回传轮也临时禁用工具调用。部署时请使用**专用的 Jarvis 测试会话，不配置真实设备工具或自动任务**。
+
+## 安装与回滚
+
+1. 在目标机运行只读脚本；确认运行中的 desktop 宿主、Aurabot 已激活、主人 QQ 私聊支持模块工具。检查是否已有专用 Jarvis 测试会话和准确 ID。若主人使用“纯聊天”档，先停在这里：不升级现有权限。可在另一步加入受信的显式主人私聊命令入口。
+2. 确认扩展面板显示的用户模块目录。默认是 `~/.dsh/plugins-data/aurabot/modules/`，以面板实际目录为准。检查没有同名模块。把解包所得的 `package/module/` 复制到用户模块目录，命名为 `rez-task-handoff`，确保其中直接包含 `index.mjs` 和 `ledger.mjs`。此动作会触发 Aurabot 热加载；通常无需重启。模块设置默认未启用。请在 Aurabot 的扩展面板确认模块加载，不使用 DSH 的 `plugin add`。
+3. 在 Aurabot 扩展面板输入自己指定的主人 QQ 与 Jarvis 完整会话 ID，先只勾选模拟交接。保持目标会话可用。启用后，提交模拟任务将调用配置中的模型，可能产生普通模型用量；自动回传开关仍关闭。真实 QQ 测试经用户确认后才开启回传，继续遵守 Aurabot 的总开关和试运行。
+4. 回滚：先关闭模块内启用与回传开关，等待测试轮结束，再从扩展面板停用模块，并将 `modules/rez-task-handoff/` 移出扫描目录。只影响这个模块，不覆盖大肥鱼、RezSuite 或桌面应用。账本位于 Aurabot 数据目录下的 `modules-data/rez-task-handoff/tasks.json`，可备份留查；卸载不删除它。已提交到 DSH 或网关的消息不能从模块撤回。
+
+从 beta.1 升级时，等当前测试和回传结束，停用扩展并将旧目录移出扫描目录，再按相同的模块目录名放入新版并启用。账本格式兼容。需要回滚时，按同样方法换回旧目录。查询支持完整任务编号或显示的 8 位短编号，发生短编号冲突时需提供完整编号。
+
+## 测试与实机验收
+
+快速单元测试（纯 Node，零依赖）：
+
+```bash
+node --test test/module.test.mjs
+```
+
+原生组合测试：将上游 **v1.1.24** 源码解包到临时目录；在另一临时目录安装 npm 上明确锁定的 `@deepseek-ai/dsh-agent-loop-testkit@0.2.1-rc.5`、`@deepseek-ai/dsh-agent-loop@0.2.1-rc.5`、`@deepseek-ai/dsh-tools@0.2.1-rc.5`。测试加载真实模块 API、真实 DSH AgentLoop 和真实 Aurabot hub，只替换模型和网关，在临时目录写模拟数据。
+
+```bash
+HANDOFF_DSH_FIXTURE=/绝对路径/临时运行时 \
+HANDOFF_AURABOT_FIXTURE=/绝对路径/aurabot-1.1.24 \
+HANDOFF_REAL_DELAY=1 node --test test/native.test.mjs
+```
+
+2026-11-04 beta.2 结果为 11 项单元测试、1 项原生组合测试通过。Aurabot 从临时用户模块目录加载扩展。两条各约 20 秒的任务（成功和失败）约 42 秒完成，等待期间原会话能继续聊天，后续输出各发送一次到模拟 OneBot。Jarvis 从 PTC 预设继承的工具呈现方式在任务结束后恢复。单元测试覆盖超时、确认、目标丢失、源会话更换、权限隔离、重复提交、模块重启恢复、短编号查询，以及含糊的重试不入队。beta.2 尚未在目标 Mac mini 和真实 QQ 上验证，也未模拟整机断电。Aurabot 面板自身的模拟会话没有真实主人私聊映射。
+
+实机顺序：主人私聊发送「让 Jarvis 做交接测试 success」→ 拿到编号 → 立即再聊一句 → 等结果；接着连续发两条（等各自收到编号，避免上游合并为一轮），再分别测 failure、timeout、confirmation。最后用同一任务 ID 查询状态，并验证非主人和群聊不会产生任务。断电/重启测试先把相关工作保存，确认测试实例处于安全状态后单独做。

package/inspect.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+// Read-only. Print selected version/presence fields, never profile contents,
+// process arguments, auth/config files, environment values or session logs.
+import { execFileSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+const home = process.argv[2] || process.env.DSH_HOME || join(homedir(), '.dsh')
+const app = process.argv[3] || '/Applications/DeepSeek Harness.app'
+const desktop = join(home, 'profiles', 'desktop')
+const manifest = file => {
+  try { return JSON.parse(readFileSync(file, 'utf8')) } catch { return undefined }
+}
+const version = v => typeof v === 'string' && /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(v) ? v : null
+const profile = manifest(join(desktop, 'package.json'))
+const bundles = profile?.dsh?.profile?.bundles
+const plugins = {}
+for (const name of ['dsh-aurabot-qq', '@rezti/dsh-rez-suite']) {
+  plugins[name] = {
+    packageVersion: version(manifest(join(desktop, 'node_modules', name, 'package.json'))?.version),
+    inDesktopBundleList: Array.isArray(bundles) ? bundles.includes(name) : null,
+  }
+}
+function getStdout(program, args) {
+  try {
+    return execFileSync(program, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000 })
+  } catch { return undefined }
+}
+const plist = join(app, 'Contents', 'Info.plist')
+const processNames = getStdout('/bin/ps', ['-axo', 'comm='])
+const info = {
+  installedDesktopAppVersion: version(getStdout('/usr/libexec/PlistBuddy',
+    ['-c', 'Print CFBundleShortVersionString', plist])?.trim()),
+  appExecutableSeen: processNames === undefined ? null :
+    processNames.split('\n').some(line => line.trim().startsWith(join(app, 'Contents', 'MacOS') + '/')),
+  desktopProfilePresent: Boolean(profile),
+  desktopPackages: plugins,
+  modulePathPresent: existsSync(join(process.env.AURABOT_DATA_DIR || join(home, 'plugins-data', 'aurabot'),
+    'modules', 'rez-task-handoff', 'index.mjs')),
+  requiresUiCheck: ['运行中的宿主版本和 profile', '插件面板是否已激活 Aurabot 与 RezSuite',
+    '大肥鱼主人私聊的工具档位', 'Jarvis 专用会话是否存在以及固定会话 ID'],
+}
+console.log(JSON.stringify(info, null, 2))

package/module/index.mjs

@@ -0,0 +1,454 @@
+import { randomUUID } from 'node:crypto'
+import { setTimeout as sleep } from 'node:timers/promises'
+import { openLedger, PENDING, setState } from './ledger.mjs'
+
+const ID = 'rez-task-handoff'
+const MOCK = 'rez_jarvis_simulate'
+const MODES = ['success', 'failure', 'timeout', 'confirmation']
+const VERSION = '1.1.24'
+const STAMP = '[rez-task-handoff:'
+const RUN_LIMIT = 90_000
+const QUEUE_LIMIT = 120_000
+const CONFIRM_LIMIT = 600_000
+const NOTE_LIMIT = 600_000
+const TIMEOUT_DEMO = 4000
+const sidKey = value => String(value ?? '').replace(/^session-/, '')
+const sameId = (a, b) => Boolean(sidKey(a) && sidKey(a) === sidKey(b))
+const exactId = agent => String(agent?.session?.id ?? '')
+const idPattern = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/
+const ownerPattern = /^\d{5,15}$/
+const submitPattern = /^(?:请\s*)?(?:让\s*Jarvis\s*(?:做|重做)\s*)?交接\s*测试(?:\s+(success|failure|timeout|confirmation))?$/i
+const submitHint = '请在主人 QQ 私聊发送「让 Jarvis 做交接测试 success」发起一条新的模拟任务。'
+const pluginMessage = (id, text) => ({
+  id, role: 'user', source: { kind: ID, form: 'relay' },
+  content: [{ type: 'text', text }],
+})
+const outcomeText = task => `任务 ${task.id}：${task.state}。 ${task.result || ''}`
+
+// Kept separate so the native scheduler, clock and transport can be exercised without QQ or a model.
+export function setupHandoff(api, { now = Date.now, delay = sleep, demoMs = 20_000 } = {}) {
+  const hub = api.core?.hub
+  const ctx = api.dsh
+  const agents = ctx?.get?.('agents')
+  const registry = ctx?.get?.('tools')
+  if (api.version !== VERSION || api.apiVersion !== 1 ||
+      typeof hub?.sessions !== 'function' || typeof hub?.chatOfSession !== 'function' ||
+      typeof ctx?.on !== 'function' || typeof agents?.get !== 'function' ||
+      typeof registry?.schemas !== 'function') {
+    api.log.warn('跨会话交接未启用：扩展 API 与验证版本不匹配。')
+    return
+  }
+
+  const ledger = openLedger(api.dataDir('tasks.json'), now)
+  const permits = new Map()
+  const sourceAgents = new Map()
+  let active
+  let disposed = false
+  let broken = false
+
+  function config() {
+    const s = api.settings()
+    const owner = String(s.ownerQQ ?? '').trim()
+    const target = String(s.jarvisSessionId ?? '').trim()
+    if (disposed || broken || s.enabled !== true || !ownerPattern.test(owner) ||
+        !idPattern.test(target) || !api.isOwner(owner)) return
+    return { owner, chatId: 'private:' + owner, target, notify: s.notify === true }
+  }
+  function findAgent(id) {
+    const agent = agents.get(id) ?? agents.get(sidKey(id)) ?? agents.get('session-' + sidKey(id))
+    return sameId(exactId(agent), id) ? agent : undefined
+  }
+  function findTarget(id) {
+    const agent = agents.get(id)
+    return exactId(agent) === id ? agent : undefined
+  }
+  function mapped(chatId, sessionId) {
+    return sameId(hub.sessions()?.[chatId]?.sessionId, sessionId) && hub.chatOfSession(sessionId) === chatId
+  }
+  function isJarvis(id) {
+    return !hub.chatOfSession(id) && !Object.values(hub.sessions() ?? {}).some(row => sameId(row?.sessionId, id))
+  }
+  function changed(fn) {
+    if (disposed || broken) throw new Error('交接已停止。')
+    try { return ledger.transaction(fn) } catch {
+      broken = true
+      active?.abort.abort()
+      api.log.error('任务账本写入失败，交接已停止。请保留数据并检查磁盘。')
+      throw new Error('交接账本不可用。')
+    }
+  }
+  function finish(id, state, result) {
+    if (disposed || broken) return
+    changed(tasks => {
+      const t = tasks.find(t => t.id === id)
+      if (t?.state === 'running') setState(t, state, result, now())
+    })
+  }
+
+  function authorize(where, exec) {
+    const c = config()
+    const agent = exec?.agent
+    const id = exactId(agent)
+    if (!c || where.chat.kind !== 'private' || where.chat.chatId !== c.chatId ||
+        !sameId(id, where.sessionId) || !mapped(c.chatId, id) || sameId(id, c.target) ||
+        typeof agent?.session?.eventAt !== 'function') return
+    const session = agent.session
+    // Check the latest turn only, using identifiers issued by the trusted prompt hook.
+    for (let seq = session.seq - 1; seq >= Math.max(0, session.seq - 128); seq--) {
+      const e = session.eventAt(seq)
+      if (e?.type === 'turn/start' || e?.type === 'turn/end') break
+      if (e?.type !== 'user/message') continue
+      if (e.data?.source?.kind === 'runtime-context') continue
+      if (e.data?.source?.kind !== 'aurabot') return
+      for (const block of e.data.content ?? []) {
+        if (block?.type !== 'text' || typeof block.text !== 'string' || !block.text.startsWith(STAMP)) continue
+        const permit = permits.get(block.text)
+        if (!permit || !sameId(permit.sessionId, id) || permit.chatId !== c.chatId ||
+            now() - permit.at >= QUEUE_LIMIT || !e.data.id) continue
+        // A copied marker cannot become a fresh authorization for another message.
+        if (permit.messageId && permit.messageId !== e.data.id) continue
+        permit.messageId = e.data.id
+        return { c, id, messageId: e.data.id, confirm: permit.confirm, requested: permit.requested }
+      }
+      return
+    }
+  }
+
+  api.on('prompt', (content, info) => {
+    const c = config()
+    const sid = String(info?.sessionId ?? '')
+    if (!c || !sid || info.chat?.kind !== 'private' ||
+        info.chat.chatId !== c.chatId || String(info.senderId) !== c.owner ||
+        !mapped(c.chatId, sid)) return
+    const source = findAgent(sid)
+    if (!source || sameId(exactId(source), c.target)) return
+    sourceAgents.set(c.chatId, source)
+    const query = String(info.queryText ?? '').trim()
+    const stamp = STAMP + randomUUID() + ']'
+    const confirm = /^确认交接\s+([a-f0-9-]{36})$/i.exec(query)?.[1]?.toLowerCase()
+    for (const [key, p] of permits) if (now() - p.at >= QUEUE_LIMIT) permits.delete(key)
+    if (permits.size >= 256) permits.delete(permits.keys().next().value)
+    const request = submitPattern.exec(query)
+    permits.set(stamp, { chatId: c.chatId, sessionId: sid, at: now(), confirm,
+      requested: request ? (request[1]?.toLowerCase() ?? 'success') : undefined })
+    return [...content, { type: 'text', text: stamp }]
+  })
+
+  const denied = () => ({ ok: false, message: '交接只接受已授权的主人 QQ 私聊消息。' })
+  const result = t => ({ ok: true, taskId: t.id, status: t.state, message: outcomeText(t) })
+  api.tool(where => {
+    const c = config()
+    if (!c || where.chat?.kind !== 'private' || where.chat.chatId !== c.chatId) return []
+    return [
+      api.defineTool({
+        name: 'rez_handoff_submit',
+        description: '提交主人明确指定的 Jarvis 模拟交接。以主人当条消息指定的模式为准，立即返回任务编号。',
+        properties: { mode: { type: 'string', enum: MODES } },
+        required: ['mode'],
+        execute(args, exec) {
+          const auth = authorize(where, exec)
+          if (!auth) return denied()
+          if (!auth.requested) return { ok: false, message: submitHint }
+          if (!MODES.includes(args?.mode)) return { ok: false, message: '只支持四种模拟任务。' }
+          const existing = ledger.tasks().find(t => t.sourceSessionId === auth.id && t.requestId === auth.messageId)
+          if (existing) return result(existing)
+          const target = findTarget(auth.c.target)
+          if (!target || !isJarvis(auth.c.target)) {
+            return { ok: false, message: '固定 Jarvis 会话未就绪。请先在桌面打开专用会话。' }
+          }
+          if (ledger.tasks().filter(t => PENDING.has(t.state)).length >= 10) {
+            return { ok: false, message: '待处理任务已满。' }
+          }
+          const t = changed(tasks => {
+            const t = {
+              id: randomUUID(), sourceChatId: auth.c.chatId, sourceSessionId: auth.id,
+              requestId: auth.messageId, targetSessionId: auth.c.target,
+              mode: auth.requested, state: 'queued', createdAt: now(), updatedAt: now(), notices: [],
+            }
+            tasks.push(t)
+            return t
+          })
+          return { ...result(t), message: `已接收模拟任务 ${t.id}，正在排队；完成后再通知。` }
+        },
+      }),
+      api.defineTool({
+        name: 'rez_handoff_status',
+        description: '查看主人私聊提交的任务状态与回传状态。接受完整编号或显示的 8 位短编号，省略则查询最新一条。',
+        properties: { taskId: { type: 'string' } },
+        execute(args, exec) {
+          const auth = authorize(where, exec)
+          if (!auth) return denied()
+          const taskId = String(args?.taskId ?? '').trim().toLowerCase()
+          const short = /^[a-f0-9]{8}$/.test(taskId)
+          const tasks = ledger.tasks().filter(t => t.sourceChatId === auth.c.chatId &&
+            (!taskId || (short ? t.id.startsWith(taskId) : t.id === taskId)))
+          if (short && tasks.length > 1) return { ok: false, message: '短编号对应多条任务，请提供完整任务编号。' }
+          const t = tasks.at(-1)
+          if (!t) return { ok: false, message: '未找到该任务。' }
+          const notice = t.notices.at(-1)
+          return { ...result(t), notification: notice?.state ?? 'not_ready',
+            message: outcomeText(t) + ' 回传状态：' + ({
+              pending: '待投递', dispatching: '准备交给原会话',
+              submitted: '已交给原会话，QQ 投递未核实',
+              unknown: '投递结果不明，不自动重发',
+              suppressed: '当前配置关闭自动回传', expired: '回传已过期',
+              rendered: '原会话已生成回复，QQ 投递未核实',
+            }[notice?.state] ?? '尚无回传') }
+        },
+      }),
+      api.defineTool({
+        name: 'rez_handoff_confirm',
+        description: '仅在主人明确说「确认交接 <完整任务编号>」时确认该模拟任务。',
+        properties: { taskId: { type: 'string' } },
+        required: ['taskId'],
+        execute(args, exec) {
+          const auth = authorize(where, exec)
+          if (!auth || !auth.confirm || auth.confirm !== args?.taskId) return denied()
+          const t = changed(tasks => {
+            const t = tasks.find(t => t.id === args.taskId && t.sourceChatId === auth.c.chatId &&
+              t.sourceSessionId === auth.id && t.targetSessionId === auth.c.target)
+            if (!t || t.state !== 'needs_confirmation' || now() - t.updatedAt >= CONFIRM_LIMIT) return
+            for (const n of t.notices) if (n.state === 'pending') n.state = 'superseded'
+            Object.assign(t, { confirmed: true, state: 'queued', updatedAt: now(), result: '' })
+            delete t.run
+            return t
+          })
+          return t ? { ...result(t), message: '已确认，模拟任务重新入队。' } :
+            { ok: false, message: '任务不在等待确认状态，或确认已过期。' }
+        },
+      }),
+    ]
+  })
+  api.rule(kind => kind === 'private' && config()
+    ? '主人明确说「让 Jarvis 做交接测试 success」或指定 failure、timeout、confirmation 时用 rez_handoff_submit，保留完整任务编号。询问 Jarvis 能做什么时，说明本模块只支持这四种模拟，不提交任务。「再试一下」本身不提交任务，可提示主人发一条明确的模拟测试请求。查交接状态用 rez_handoff_status。只有工具确认入队时才说已入队。结果回传轮只简短告知结果，不调用工具。' : '')
+
+  function release(run) {
+    if (active === run) active = undefined
+    for (const off of run.offs.reverse()) {
+      try { off() } catch { /* agent may already be disposed */ }
+    }
+  }
+
+  function launch(task, agent) {
+    const tools = agent.ctx?.tools
+    const run = { id: task.id, target: exactId(agent), messageId: randomUUID(), abort: new AbortController(), offs: [],
+      deadline: now() + (task.mode === 'timeout' ? TIMEOUT_DEMO : RUN_LIMIT) }
+    active = run
+    let isolationError = 'Jarvis 工具隔离接口不可用，请使用专用的标准会话。'
+    try {
+      if (typeof tools?.guard !== 'function' || typeof tools?.register !== 'function' ||
+          typeof tools?.restrict !== 'function' || typeof agent.whenIdle !== 'function') {
+        throw new Error('Jarvis 的工具隔离接口不可用。')
+      }
+      if (registry.schemas(agent).some(t => t.name === 'run_code')) {
+        isolationError = 'Jarvis 的 PTC 工具模式无法临时切换，请使用专用的标准会话。'
+        run.offs.push(tools.presentAs('native'))
+      }
+      isolationError = 'Jarvis 工具隔离检查失败，请使用专用的标准会话。'
+      run.offs.push(tools.restrict({ allow: [] }))
+      run.offs.push(tools.guard(exec => exec.name === MOCK ? undefined : 'Jarvis 模拟会话禁止使用其他工具。'))
+      run.offs.push(tools.register(api.defineTool({
+        name: MOCK,
+        description: '执行当前交接的唯一无害模拟步骤。无须参数；不可执行系统或设备操作。',
+        async execute(_args, exec) {
+          if (disposed || broken || !config() || active !== run ||
+              exactId(exec?.agent) !== run.target || run.turn === undefined) {
+            return { ok: false, message: '没有可执行的交接。' }
+          }
+          if (typeof exec.concludeTurn !== 'function' || !exec.signal) {
+            return { ok: false, message: '当前宿主不能安全结束模拟轮次。' }
+          }
+          const accepted = changed(tasks => {
+            const t = tasks.find(t => t.id === task.id)
+            if (t?.state !== 'running' || t.run?.messageId !== run.messageId || t.run.claimed) return false
+            t.run.claimed = true
+            return true
+          })
+          if (!accepted) return { ok: false, message: '该模拟步骤已执行或已失效。' }
+          const signal = AbortSignal.any([run.abort.signal, exec.signal])
+          await delay(task.mode === 'timeout' ? TIMEOUT_DEMO + 10_000 : demoMs, undefined, { signal })
+          if (disposed || broken || signal.aborted || active !== run) return { ok: false, message: '任务已中断。' }
+          run.outcome = task.mode === 'failure' ? ['failed', '模拟执行失败。'] :
+            task.mode === 'confirmation' && !task.confirmed
+              ? ['needs_confirmation', `需要主人确认。请发送：确认交接 ${task.id}`]
+              : ['completed', 'Jarvis 的模拟步骤完成，未操作真实设备。']
+          exec.concludeTurn()
+          return { ok: true, message: run.outcome[1] }
+        },
+      })))
+      const remaining = registry.schemas(agent).map(t => t.name)
+      if (remaining.length !== 1 || remaining[0] !== MOCK) {
+        isolationError = 'Jarvis 仍有额外工具，模拟任务未投递。请使用专用的标准会话。'
+        throw new Error(isolationError)
+      }
+      changed(tasks => {
+        const t = tasks.find(t => t.id === task.id)
+        t.run = { messageId: run.messageId, deadline: run.deadline }
+        setState(t, 'running', '', now())
+      })
+    } catch {
+      try { if (!broken) changed(tasks => {
+        const t = tasks.find(t => t.id === task.id)
+        if (t && ['queued', 'running'].includes(t.state)) {
+          setState(t, 'failed', isolationError, now())
+        }
+      }) } finally { release(run) }
+      return
+    }
+
+    // Do not await either followup or whenIdle from the QQ tool.
+    const submit = () => agent.followup(pluginMessage(run.messageId,
+      `交接测试 ${task.id}。只调用一次 ${MOCK}，不要自行执行任何设备、文件或系统操作。`))
+    try {
+      const accepted = typeof agents.withoutInitiator === 'function' ? agents.withoutInitiator(submit) : submit()
+      Promise.resolve(accepted).catch(() => finish(task.id, 'failed', 'Jarvis 未接受模拟轮次。'))
+        .finally(() => agent.whenIdle())
+        .catch(() => {})
+        .finally(() => {
+          try { finishIfRunning(run) } finally { release(run) }
+        }).catch(() => {})
+    } catch {
+      // A thrown send does not prove nothing was enqueued. Keep the guard until idle.
+      try { finish(task.id, 'failed', 'Jarvis 轮次提交结果不明，未重试。') } finally {
+        Promise.resolve().then(() => agent.whenIdle()).then(() => release(run), () => {}).catch(() => {})
+      }
+    }
+  }
+
+  function finishIfRunning(run) {
+    if (!disposed && !broken && ledger.tasks().some(t => t.id === run.id && t.state === 'running')) {
+      finish(run.id, 'failed', 'Jarvis 未产生可关联的模拟结果。')
+    }
+  }
+
+  // Follow the native turn boundary. A completed unrelated turn cannot settle this task.
+  const replies = new Map()
+  function releaseReply(sid, pending) {
+    if (replies.get(sid) !== pending) return
+    replies.delete(sid)
+    try { pending.off() } catch { /* scope may already be disposed */ }
+  }
+  const off = ctx.on('session/event', (session, event) => {
+    if (disposed || broken) return
+    const sid = String(session?.id ?? '')
+    const run = active
+    try {
+      if (run && sid === run.target) {
+        if (event.type === 'turn/start') run.openTurn = event.data.turn
+        if (event.type === 'user/message' && event.data.id === run.messageId) run.turn = run.openTurn
+        if (event.type === 'turn/end' && event.data.turn === run.turn) {
+          const out = now() >= run.deadline ? ['timed_out', '模拟任务超时，未自动重试。'] :
+            event.data.reason?.kind === 'completed' ? run.outcome : undefined
+          finish(run.id, ...(out ?? ['failed', 'Jarvis 轮次未正常完成，或没有执行模拟步骤。']))
+        }
+      }
+      const pending = replies.get(sid)
+      if (!pending) return
+      if (event.type === 'turn/start') pending.openTurn = event.data.turn
+      if (event.type === 'user/message' && event.data.id === pending.id) pending.turn = pending.openTurn
+      if (event.type === 'assistant/message' && event.data.turn === pending.turn && !event.data.interrupted &&
+          event.data.message?.content?.some(b => b.type === 'text' && b.text?.trim())) pending.hasText = true
+      if (event.type === 'turn/end' && event.data.turn === pending.turn) {
+        const state = event.data.reason?.kind === 'completed' && pending.hasText ? 'rendered' : 'unknown'
+        try { markNotice(pending.taskId, pending.id, state) } finally { releaseReply(sid, pending) }
+      }
+    } catch { /* ledger errors already disable the module; never break the host listener */ }
+  })
+
+  function markNotice(taskId, noticeId, state) {
+    changed(tasks => {
+      const n = tasks.find(t => t.id === taskId)?.notices.find(n => n.id === noticeId)
+      if (n && ['pending', 'dispatching', 'submitted'].includes(n.state)) Object.assign(n, { state, updatedAt: now() })
+    })
+  }
+
+  function notify(tasks, c) {
+    for (const t of tasks) {
+      if (t.sourceChatId !== c.chatId || t.targetSessionId !== c.target) continue
+      const n = t.notices.find(n => n.state === 'pending')
+      if (!n) continue
+      if (now() - n.createdAt >= NOTE_LIMIT) { markNotice(t.id, n.id, 'expired'); continue }
+      if (!c.notify) { markNotice(t.id, n.id, 'suppressed'); continue }
+      // Pin the original session. Never ask Aurabot to create/rotate a session for a notification.
+      const source = sourceAgents.get(c.chatId)
+      const current = findAgent(t.sourceSessionId)
+      if (!source || source !== current || !mapped(c.chatId, t.sourceSessionId) || source.status !== 'idle' ||
+          replies.has(t.sourceSessionId) || api.core.mutes?.muted?.(c.chatId)) continue
+      if (typeof source.ctx?.tools?.guard !== 'function' || typeof source.whenIdle !== 'function') continue
+      const note = `【交接系统通知】任务 ${t.id}，状态 ${n.outcome}。 ${n.result}\n请结合本 QQ 会话，用简短自然的话告知主人，保留任务编号和真实状态。不要调用工具。`
+      const off = source.ctx.tools.guard(() => '交接回传轮只允许生成文字。')
+      const pending = { taskId: t.id, id: n.id, at: now(), off }
+      replies.set(t.sourceSessionId, pending)
+      try {
+        markNotice(t.id, n.id, 'dispatching')
+        try {
+          Promise.resolve(source.followup(pluginMessage(n.id, note))).then(
+            () => { if (!disposed && !broken) markNotice(t.id, n.id, 'submitted') },
+            () => { if (!disposed && !broken) markNotice(t.id, n.id, 'unknown') },
+          ).catch(() => {})
+        } catch { markNotice(t.id, n.id, 'unknown') }
+        Promise.resolve().then(() => source.whenIdle()).then(() => {
+          if (replies.get(t.sourceSessionId) !== pending) return
+          try { if (!disposed && !broken) markNotice(t.id, n.id, 'unknown') }
+          finally { releaseReply(t.sourceSessionId, pending) }
+        }).catch(() => {})
+      } catch {
+        releaseReply(t.sourceSessionId, pending)
+      }
+      return
+    }
+  }
+
+  function tick() {
+    if (disposed || broken) return
+    const c = config()
+    const rows = ledger.tasks()
+    for (const note of replies.values()) if (!note.timedOut && now() - note.at >= RUN_LIMIT) {
+      note.timedOut = true
+      markNotice(note.taskId, note.id, 'unknown')
+    }
+    for (const t of rows) {
+      const stale = !c || c.chatId !== t.sourceChatId || t.targetSessionId !== c.target
+      if (t.state === 'running' && (stale || now() >= t.run.deadline)) {
+        finish(t.id, stale ? 'interrupted' : 'timed_out', stale ? '交接已停用或绑定已更改。' : '模拟任务超时，未自动重试。')
+        if (active?.id === t.id) active.abort.abort()
+      } else if ((t.state === 'queued' && (stale || now() - t.updatedAt >= QUEUE_LIMIT)) ||
+          (t.state === 'needs_confirmation' && now() - t.updatedAt >= CONFIRM_LIMIT)) {
+        changed(tasks => setState(tasks.find(x => x.id === t.id), stale ? 'interrupted' : 'timed_out',
+          stale ? '交接已停用或绑定已更改。' : '排队或确认等待已过期。', now()))
+      }
+    }
+    if (!c) return
+    const fresh = ledger.tasks()
+    if (!active) {
+      const t = fresh.find(t => t.state === 'queued')
+      const target = t && findTarget(t.targetSessionId)
+      if (target?.status === 'idle' && isJarvis(t.targetSessionId)) launch(t, target)
+    }
+    notify(fresh, c)
+  }
+
+  api.every(1000, tick, '交接后台处理')
+  api.onDispose(() => {
+    disposed = true
+    off()
+    active?.abort.abort()
+    permits.clear()
+    sourceAgents.clear()
+  })
+}
+
+export default {
+  id: ID,
+  name: 'Jarvis 跨会话交接（模拟）',
+  version: '0.1.0-beta.2',
+  api: 1,
+  description: '把主人私聊的模拟任务交给指定 Jarvis 会话并回传结果。',
+  settings: [
+    { key: 'enabled', label: '启用模拟交接', type: 'switch' },
+    { key: 'ownerQQ', label: '主人 QQ 号（须与大肥鱼设置一致）', type: 'text' },
+    { key: 'jarvisSessionId', label: 'Jarvis 会话 ID', type: 'text' },
+    { key: 'notify', label: '允许回到原 QQ 会话主动通知', type: 'switch' },
+  ],
+  setup: setupHandoff,
+}

package/module/ledger.mjs

@@ -0,0 +1,66 @@
+import { randomUUID } from 'node:crypto'
+import { closeSync, fsyncSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+const MAX_TASKS = 1000
+export const PENDING = new Set(['queued', 'running', 'needs_confirmation'])
+
+export function setState(task, state, result, now) {
+  Object.assign(task, { state, result, updatedAt: now })
+  if (state !== 'queued' && state !== 'running') {
+    task.notices.push({ id: randomUUID(), state: 'pending', outcome: state, result, createdAt: now, updatedAt: now })
+  }
+}
+
+export function openLedger(path, now = Date.now) {
+  let snapshot = { version: 1, tasks: [] }
+  try {
+    snapshot = JSON.parse(readFileSync(path, 'utf8'))
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw new Error('无法读取任务账本；请保留文件并停用模块排查。')
+  }
+  if (snapshot?.version !== 1 || !Array.isArray(snapshot.tasks) || snapshot.tasks.length > MAX_TASKS ||
+      snapshot.tasks.some(task => !task || typeof task.id !== 'string' || !Array.isArray(task.notices))) {
+    throw new Error('无法识别任务账本；请保留文件并停用模块排查。')
+  }
+
+  function transaction(fn) {
+    const next = structuredClone(snapshot)
+    const result = fn(next.tasks)
+    if (next.tasks.length > MAX_TASKS) throw new Error('任务账本已满，请停用模块后备份归档。')
+    const tmp = join(dirname(path), '.handoff-' + randomUUID() + '.tmp')
+    try {
+      const fd = openSync(tmp, 'wx', 0o600)
+      try {
+        writeFileSync(fd, JSON.stringify(next) + '\n', 'utf8')
+        fsyncSync(fd)
+      } finally {
+        closeSync(fd)
+      }
+      renameSync(tmp, path)
+      snapshot = next
+    } finally {
+      try { unlinkSync(tmp) } catch (error) { if (error.code !== 'ENOENT') throw error }
+    }
+    return structuredClone(result)
+  }
+
+  if (snapshot.tasks.some(t => ['queued', 'running'].includes(t.state) ||
+      t.notices.some(n => n.state === 'dispatching'))) {
+    transaction(tasks => {
+      for (const t of tasks) {
+        if (['queued', 'running'].includes(t.state)) {
+          setState(t, 'interrupted', '模块中断，未自动重跑。', now())
+        }
+        for (const notice of t.notices) {
+          if (notice.state === 'dispatching') {
+            notice.state = 'unknown'
+            notice.updatedAt = now()
+          }
+        }
+      }
+    })
+  }
+
+  return { tasks: () => structuredClone(snapshot.tasks), transaction }
+}

package/package.json

@@ -1,6 +1,27 @@
 {
   "name": "@rezti/dsh-rez-task-handoff",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-beta.2",
+  "description": "Aurabot user module for simulated cross-session Jarvis task handoffs in DeepSeek Harness.",
+  "type": "module",
+  "main": "./module/index.mjs",
+  "exports": "./module/index.mjs",
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "files": [
+    "inspect.mjs",
+    "module/index.mjs",
+    "module/ledger.mjs"
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ReZ-TI/deepseek-harness.git",
+    "directory": "extensions/rez-task-handoff"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public",
+    "tag": "beta"
+  }
+}