@roaming-ai/dsh-group-chat 0.3.1 → 0.4.0

package/src/client/components/SpeakerOrb.tsx

@@ -0,0 +1,201 @@
+/**
+ * 发言人执行态点阵光球（live 行头像内容）：角色色单色点阵 Canvas 2D 动画。
+ * thinking（轨道热斑游走＝等待首字节/推理中）与 listening（向外涟漪＝正文
+ * 流出）两态间弹簧缩放 + 权重交叉淡入；裁掉参考实现 MatrixOrb 的 label、
+ * level 与 idle 态（本场景只有执行中一种挂载时机），尺寸钉死为头像内容盒。
+ * @module dsh-group-chat/client/SpeakerOrb
+ */
+
+import { useEffect, useRef, useSyncExternalStore, type ReactNode } from 'react'
+
+export type SpeakerOrbState = 'thinking' | 'listening'
+
+const TAU = Math.PI * 2
+const STATES: SpeakerOrbState[] = ['thinking', 'listening']
+
+/** 头像内容盒：28px 外框减 2px 描边 ×2；圆形轮廓由 d 截断近似。 */
+const SIZE = 24
+const GRID = 7
+/** 点阵铺开比例：外圈点贴近描边又不被 border-radius 裁切。 */
+const SPREAD = 0.86
+
+const SCALE: Record<SpeakerOrbState, number> = { thinking: 0.94, listening: 1 }
+const STIFFNESS = 180
+const DAMPING = 26
+const ATTACK = 0.22
+const RELEASE = 0.08
+const BLEND = 0.16
+
+/** thinking 态热斑轨道（点阵归一化坐标）。 */
+const ORBITERS = [
+  { radius: 0.62, speed: 2.2, phase: 0, spread: 0.42 },
+  { radius: 0.4, speed: -1.7, phase: 2.1, spread: 0.36 },
+  { radius: 0.8, speed: 1.15, phase: 4, spread: 0.34 },
+]
+
+// no Math.abs here, its corners read as a snap at every trough
+function envelope(t: number) {
+  const slow = 0.5 + 0.5 * Math.sin(t * 0.62 + 0.4)
+  const fast = 0.5 + 0.5 * Math.sin(t * 1.9 + 1.1)
+  return 0.22 + 0.78 * (0.45 + 0.55 * slow) * fast
+}
+
+function intensityOf(
+  state: SpeakerOrbState,
+  d: number,
+  nx: number,
+  ny: number,
+  t: number,
+  amplitude: number,
+) {
+  if (state === 'listening') {
+    const ripple = 0.5 + 0.5 * Math.sin(d * 4.2 - t * 3)
+    return 0.32 + amplitude * (0.34 + 0.38 * ripple)
+  }
+
+  let heat = 0
+  for (const o of ORBITERS) {
+    const a = t * o.speed + o.phase
+    const dx = nx - Math.cos(a) * o.radius
+    const dy = ny - Math.sin(a) * o.radius
+    heat += Math.exp(-(dx * dx + dy * dy) / (o.spread * o.spread))
+  }
+  return 0.26 + 0.8 * Math.min(1, heat)
+}
+
+// zoom changes devicePixelRatio, and a buffer built for the old one gets upscaled
+function subscribeToZoom(onChange: () => void) {
+  window.addEventListener('resize', onChange)
+  return () => window.removeEventListener('resize', onChange)
+}
+
+function useDevicePixelRatio() {
+  return useSyncExternalStore(
+    subscribeToZoom,
+    () => Math.min(window.devicePixelRatio || 1, 4),
+    () => 1,
+  )
+}
+
+export function SpeakerOrb(props: { state: SpeakerOrbState, color: string }): ReactNode {
+  const { state, color } = props
+  const canvasRef = useRef<HTMLCanvasElement>(null)
+  const stateRef = useRef(state)
+  const redrawRef = useRef<(() => void) | null>(null)
+  const dpr = useDevicePixelRatio()
+
+  useEffect(() => {
+    stateRef.current = state
+  }, [state])
+
+  useEffect(() => {
+    const canvas = canvasRef.current
+    const ctx = canvas?.getContext('2d')
+    if (!canvas || !ctx) return
+
+    // scaling by buffer/size, not dpr, keeps the transform exact when it rounds
+    const buffer = Math.round(SIZE * dpr)
+    canvas.width = canvas.height = buffer
+    ctx.scale(buffer / SIZE, buffer / SIZE)
+    ctx.fillStyle = color
+
+    const half = (GRID - 1) / 2
+    const spacing = (SIZE * SPREAD) / (GRID - 1)
+    const maxRadius = spacing * 0.6
+    const center = SIZE / 2
+
+    const weights: Record<SpeakerOrbState, number> = { thinking: 0, listening: 0 }
+    weights[stateRef.current] = 1
+
+    const draw = (t: number, amplitude: number, scale: number) => {
+      ctx.clearRect(0, 0, SIZE, SIZE)
+
+      for (let iy = 0; iy < GRID; iy++) {
+        for (let ix = 0; ix < GRID; ix++) {
+          const nx = (ix - half) / half
+          const ny = (iy - half) / half
+          const d = Math.hypot(nx, ny)
+          // 1.12, not the square's 1.41 corner, is what makes the outline round
+          if (d > 1.12) continue
+
+          let blended = 0
+          for (const s of STATES) {
+            if (weights[s] < 0.001) continue
+            blended += weights[s] * intensityOf(s, d, nx, ny, t, amplitude)
+          }
+
+          const intensity = Math.min(1, Math.max(0, blended))
+          const radius = maxRadius * Math.exp(-d * d * 1.7) * intensity * scale
+          // anything under half a device pixel renders as haze, not a dot
+          if (radius * dpr < 0.5) continue
+
+          ctx.beginPath()
+          ctx.arc(
+            center + (ix - half) * spacing * scale,
+            center + (iy - half) * spacing * scale,
+            radius,
+            0,
+            TAU,
+          )
+          ctx.fill()
+        }
+      }
+    }
+
+    const reduce =
+      typeof window.matchMedia === 'function' &&
+      window.matchMedia('(prefers-reduced-motion: reduce)').matches
+
+    if (reduce) {
+      redrawRef.current = () => {
+        const current = stateRef.current
+        for (const s of STATES) weights[s] = s === current ? 1 : 0
+        draw(0, envelope(0), SCALE[current])
+      }
+      redrawRef.current()
+      return () => {
+        redrawRef.current = null
+      }
+    }
+
+    let t = 0
+    let amplitude = 0
+    let scale = SCALE[stateRef.current]
+    let velocity = 0
+    let last = performance.now()
+    let raf = 0
+
+    const frame = (now: number) => {
+      const dt = Math.min((now - last) / 1000, 0.05)
+      last = now
+      t += dt
+
+      const current = stateRef.current
+      const target = envelope(t)
+      const rate = target > amplitude ? ATTACK : RELEASE
+      amplitude += (target - amplitude) * (1 - Math.pow(1 - rate, dt * 60))
+
+      // per-state weights, so interrupting a change blends from what is on screen
+      const step = 1 - Math.pow(1 - BLEND, dt * 60)
+      for (const s of STATES) {
+        weights[s] += ((s === current ? 1 : 0) - weights[s]) * step
+      }
+
+      velocity += (-STIFFNESS * (scale - SCALE[current]) - DAMPING * velocity) * dt
+      scale += velocity * dt
+
+      draw(t, amplitude, scale)
+      raf = requestAnimationFrame(frame)
+    }
+    raf = requestAnimationFrame(frame)
+
+    return () => cancelAnimationFrame(raf)
+    // state stays out of the deps on purpose: the loop retargets, it never restarts
+  }, [color, dpr])
+
+  useEffect(() => {
+    redrawRef.current?.()
+  }, [state])
+
+  return <canvas ref={canvasRef} aria-hidden className="dsgc-orb" style={{ width: SIZE, height: SIZE }} />
+}

package/src/client/lib/styles.ts

@@ -104,6 +104,9 @@ export const CSS = [
   '.dsgc-msg.mine{flex-direction:row-reverse}',
   '.dsgc-avatar{width:28px;height:28px;box-sizing:border-box;border:2px solid var(--dsw-alias-border-l3,rgba(128,128,128,.4));border-radius:50%;background:var(--dsw-alias-bg-module-platform,rgba(128,128,128,.12));color:var(--dsw-alias-label-primary,inherit);display:flex;align-items:center;justify-content:center;font-size:12px;font-weight:600;flex:none;margin-top:1px}',
   '.dsgc-avatar.mine{border-color:transparent;background:var(--dsw-alias-button-info-fill,#4f6ef7);color:var(--dsw-alias-label-primary-foreground,#fff)}',
+  /* 执行中头像点阵光球（SpeakerOrb）：inline canvas 需 block 消除基线空隙，
+     尺寸由组件内联 style 钉死为头像内容盒 24px */
+  '.dsgc-avatar .dsgc-orb{display:block}',
   '.dsgc-msgbody{max-width:76%;min-width:0;display:flex;flex-direction:column;gap:5px}',
   '.dsgc-msg.mine .dsgc-msgbody{align-items:flex-end}',
   '.dsgc-msghead{display:flex;gap:6px;align-items:center;min-width:0;font-size:12px;color:var(--dsw-alias-label-secondary,inherit)}',
@@ -201,8 +204,12 @@ export const CSS = [
   /* @提及芯片（输入区内原子元素）：色点 + 角色色淡底胶囊——弹层候选行同语言 */
   '.dsgc-chipin{display:inline-flex;align-items:center;gap:4px;background:color-mix(in srgb,var(--role-color,#888) 15%,transparent);border-radius:999px;padding:1px 7px 1px 5px;margin:0 1px;font-size:12px;line-height:18px;color:var(--dsw-alias-label-primary,inherit);white-space:nowrap;user-select:all}',
   '.dsgc-card .dsgc-sendrow{padding:0 12px 10px}',
-  '.dsgc-stopbtn{background:var(--dsw-alias-state-error-primary,#e5484d);border-color:transparent;color:#fff;font-weight:600}',
-  '.dsgc-stopbtn:hover:not(:disabled){filter:brightness(1.08);color:#fff}',
+  /* 停止/清空按钮：实心红（Button primitive outline 变体的 hover 规则
+     background:interactive-bg-hover 特异度 (0,3,0) 会盖掉 (0,1,0) 的红底，
+     悬停时按钮变透明；加 button 类型选择器提为 (0,1,1)/(0,3,1)，顺序无关
+     地压过变体，hover 补回红底并经 brightness 提亮） */
+  'button.dsgc-stopbtn{background:var(--dsw-alias-state-error-primary,#e5484d);border-color:transparent;color:#fff;font-weight:600}',
+  'button.dsgc-stopbtn:hover:not(:disabled){background:var(--dsw-alias-state-error-primary,#e5484d);filter:brightness(1.08);color:#fff}',
   /* 标签固定在左；芯片在右侧独立换行，后续行与首行芯片左缘对齐（不折到「参与角色」下面）。
      单行 24px；角色过多时随内容增高，避免固定高度把后续行溢出叠到下方输入卡上 */
   '.dsgc-parts{display:flex;align-items:flex-start;gap:6px;min-height:24px}',

package/src/core/types.ts

@@ -149,7 +149,8 @@ export interface RunState {
   queue: string[]
   pendingConfirm: PendingConfirm | null
   confirmSignal: { resolve: (allowed: boolean) => void } | null
-  childProc: import('node:child_process').ChildProcess | null
+  /** 正在执行的 run_command 的中止句柄（stop/dispose 时 abort，执行器 kill 进程）。 */
+  commandAbort: AbortController | null
   /** 最近一次 run 的结束标记：会话列表「已完成/已出错」状态的数据源。 */
   finished: RunFinished | null
   /** 原地重试时被覆盖的失败消息 id；普通 send 为 null。 */
@@ -210,7 +211,7 @@ export type SnapshotMessage = Omit<MessageRecord, 'reasoningFull' | 'thinkingSum
 /** 发到客户端的全量快照（wire 形态；各表行由领域记录派生，字段增删由编译器同步）。 */
 export interface Snapshot {
   revision: number
-  run: Omit<RunState, 'stopping' | 'queue' | 'confirmSignal' | 'childProc'>
+  run: Omit<RunState, 'stopping' | 'queue' | 'confirmSignal' | 'commandAbort'>
   lastCreated: LastCreated | null
   groups: GroupRecord[]
   sessions: SnapshotSession[]

package/src/host/engine/conversation.ts

@@ -379,7 +379,7 @@ export function createConversation(core: HostState, deps: { touch: () => void, s
       run.queue = []
       run.pendingConfirm = null
       run.confirmSignal = null
-      run.childProc = null
+      run.commandAbort = null
       run.stopping = false
       run.replaceMessageId = null
       touch()

package/src/host/persistence/persistence.ts

@@ -5,6 +5,7 @@
  */
 
 import { existsSync } from 'node:fs'
+import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write'
 import { repairFailedMessage } from '../../core/errors.ts'
 import { messageJson, roleJson } from '../../core/json.ts'
 import { sanitizeConstraints } from '../../core/constraints.ts'
@@ -25,6 +26,9 @@ interface SessionDocument {
   messages?: Partial<MessageRecord>[]
 }
 
+/** writeFileAtomic 权限位：私有数据 0o600、目录 0o700（对齐 Store.atomicWrite）。 */
+const WRITE_FILE_OPTS = { mode: 0o600, dirMode: 0o700 } as const
+
 /** 群组角色文件形态（hydrate 用）。 */
 interface RolesDocument {
   roles?: Partial<RoleRecord>[]
@@ -34,12 +38,10 @@ interface RolesDocument {
 export interface Persistence {
   /** 事件驱动落盘；同一 tick 内多次变更合并为一次写。 */
   schedulePersist: (targets?: { ledger?: boolean, session?: string | null, roles?: string | null, workspace?: string | null }) => void
-  /** 同步 flush：写全部脏文件（dispose 最终落盘用）。 */
-  flushNow: () => void
   /** 删除群组/会话后摘除脏标记（对应文件已删/将删，flush 跳过）。 */
   dropDirty: (targets: { session?: string | null, roles?: string | null, workspace?: string | null }) => void
-  /** dispose：同步最终 flush → 释放锁 → 摘除句柄。 */
-  release: () => void
+  /** dispose：停止新调度 → 等待挂起 flush → 最终 flush → 释放锁（异步）。 */
+  release: () => Promise<void>
 }
 
 /**
@@ -56,12 +58,20 @@ export function createPersistence(core: HostState): Persistence {
   }
   const store = (): Store | null => core.store
 
-  // 脏标记按文件记；flush 失败者保留脏标记，下次触发自动重试
-  const dirtySessions = new Set<string>()
-  const dirtyRoles = new Set<string>()
-  const dirtyWorkspace = new Set<string>()
-  let ledgerDirty = false
+  // 脏标记按文件记（值 = 版本号，标记时递增）；flush 期间被重新标脏的文件
+  // 保留标记待下一轮 flush（写成功后版本未变才清除），失败同理自动重试
+  const dirtySessions = new Map<string, number>()
+  const dirtyRoles = new Map<string, number>()
+  const dirtyWorkspace = new Map<string, number>()
+  let ledgerDirty = 0
   let flushScheduled = false
+  // flush 串行链：writeFileAtomic 异步化后，防止并发 flush 对同一文件乱序
+  // rename（后写的旧内容盖住先写的新内容）；链上任务逐个排队执行
+  let flushChain: Promise<void> = Promise.resolve()
+
+  const mark = (map: Map<string, number>, key: string): void => {
+    map.set(key, (map.get(key) ?? 0) + 1)
+  }
 
   const ledgerDocument = (): LedgerDocument & { savedAt: number } => ({
     schema: 3,
@@ -85,57 +95,61 @@ export function createPersistence(core: HostState): Persistence {
   })
   const rolesDocument = (g: GroupRecord) => ({ schema: 1, savedAt: Date.now(), roles: g.roleIds.map((rid) => core.roles.get(rid)).filter((r): r is RoleRecord => Boolean(r)).map((r) => roleJson(r)) })
 
-  /** 同步 flush：写全部脏文件；成功才清脏标记；每个实际发生 rename 的目录一次 fsync。 */
-  const flushNow = (): void => {
-    const s = store()
-    if (s === null) return
+  /**
+   * 异步 flush（writeFileAtomic：wx 独占创建 + 随机后缀 tmp + rename，无
+   * per-file fsync——崩溃持久性对齐 DSH 基座标准）：写全部脏文件；写成功且
+   * 写入期间未被重新标脏（版本未变）才清脏标记；每个实际发生 rename 的
+   * 目录一次 fsync（调用侧批量执行）。
+   */
+  const flushAll = async (s: Store): Promise<void> => {
     const fsyncDirs = new Set<string>()
-    for (const sid of [...dirtySessions]) {
+    for (const [sid, v] of [...dirtySessions]) {
       const sess = core.sessions.get(sid)
       if (!sess) {
         dirtySessions.delete(sid)
         continue
       }
       try {
-        s.atomicWrite(s.sessionFile(sess.groupId, sess.id), JSON.stringify(sessionDocument(sess)))
-        dirtySessions.delete(sid)
+        await writeFileAtomic(s.sessionFile(sess.groupId, sess.id), JSON.stringify(sessionDocument(sess)), WRITE_FILE_OPTS)
+        if (dirtySessions.get(sid) === v) dirtySessions.delete(sid)
         fsyncDirs.add(s.sessionsDir(sess.groupId))
       } catch (e) {
         console.error(`[dsh-group-chat] 会话 ${sid} 落盘失败（保留脏标记待重试）：`, e)
       }
     }
-    for (const gid of [...dirtyRoles]) {
+    for (const [gid, v] of [...dirtyRoles]) {
       const g = core.groups.get(gid)
       if (!g) {
         dirtyRoles.delete(gid)
         continue
       }
       try {
-        s.atomicWrite(s.rolesFile(gid), JSON.stringify(rolesDocument(g)))
-        dirtyRoles.delete(gid)
+        await writeFileAtomic(s.rolesFile(gid), JSON.stringify(rolesDocument(g)), WRITE_FILE_OPTS)
+        if (dirtyRoles.get(gid) === v) dirtyRoles.delete(gid)
         fsyncDirs.add(s.groupDir(gid))
       } catch (e) {
         console.error(`[dsh-group-chat] 群组 ${gid} roles.json 落盘失败（保留脏标记待重试）：`, e)
       }
     }
-    for (const gid of [...dirtyWorkspace]) {
+    for (const [gid, v] of [...dirtyWorkspace]) {
       const g = core.groups.get(gid)
       if (!g) {
         dirtyWorkspace.delete(gid)
         continue
       }
       try {
-        s.atomicWrite(s.workspaceFile(gid), (g.workspaceDir || '') + '\n')
-        dirtyWorkspace.delete(gid)
+        await writeFileAtomic(s.workspaceFile(gid), (g.workspaceDir || '') + '\n', WRITE_FILE_OPTS)
+        if (dirtyWorkspace.get(gid) === v) dirtyWorkspace.delete(gid)
         fsyncDirs.add(s.groupDir(gid))
       } catch (e) {
         console.error(`[dsh-group-chat] 群组 ${gid} workspaceDir 落盘失败（保留脏标记待重试）：`, e)
       }
     }
-    if (ledgerDirty) {
+    if (ledgerDirty > 0) {
+      const v = ledgerDirty
       try {
-        s.atomicWrite(s.ledgerFile, JSON.stringify(ledgerDocument(), null, 2))
-        ledgerDirty = false
+        await writeFileAtomic(s.ledgerFile, JSON.stringify(ledgerDocument(), null, 2), WRITE_FILE_OPTS)
+        if (ledgerDirty === v) ledgerDirty = 0
         fsyncDirs.add(s.dir)
       } catch (e) {
         console.error('[dsh-group-chat] ledger.json 落盘失败（保留脏标记待重试）：', e)
@@ -147,15 +161,22 @@ export function createPersistence(core: HostState): Persistence {
   /** 事件驱动落盘；同一 tick 内多次变更合并为一次写。 */
   const schedulePersist = ({ ledger = false, session = null, roles: roleGroup = null, workspace = null }: { ledger?: boolean, session?: string | null, roles?: string | null, workspace?: string | null } = {}): void => {
     if (store() === null) return
-    if (ledger) ledgerDirty = true
-    if (session) dirtySessions.add(session)
-    if (roleGroup) dirtyRoles.add(roleGroup)
-    if (workspace) dirtyWorkspace.add(workspace)
+    if (ledger) ledgerDirty++
+    if (session) mark(dirtySessions, session)
+    if (roleGroup) mark(dirtyRoles, roleGroup)
+    if (workspace) mark(dirtyWorkspace, workspace)
     if (flushScheduled) return
     flushScheduled = true
     void Promise.resolve().then(() => {
       flushScheduled = false
-      flushNow()
+      // 排队进串行链；flushAll 按文件吞错（保留脏标记），此处兜底意外
+      // 逃逸的异常并把链复位为健康态，后续 flush 不被跳过
+      flushChain = flushChain.then(async () => {
+        const s = store()
+        if (s !== null) await flushAll(s)
+      }).catch((e) => {
+        console.error('[dsh-group-chat] 落盘 flush 异常（脏标记保留待重试）：', e)
+      })
     })
   }
 
@@ -311,18 +332,20 @@ export function createPersistence(core: HostState): Persistence {
 
   return {
     schedulePersist,
-    flushNow,
     dropDirty,
-    release(): void {
+    async release(): Promise<void> {
       const s = store()
       if (s === null) return
+      // 立即停止新调度并摘除句柄（后续 schedulePersist 直接 no-op）；
+      // 持有的 store 引用继续完成最终落盘
+      core.store = null
       try {
-        flushNow()
+        await flushChain
+        await flushAll(s)
       } catch {}
       try {
         s.release()
       } catch {}
-      core.store = null
     },
   }
 }

package/src/host/persistence/store.ts

@@ -126,7 +126,11 @@ export class Store {
     } catch {}
   }
 
-  /** 原子写：tmp+fsync+rename；目录 fsync 由调用方按 flush 批量执行（每目录一次）。 */
+  /**
+   * 同步原子写（tmp+fsync+rename）：仅供构造期 v1 迁移（migrateV1）与测试
+   * 直用；运行时 flush 走 persistence.ts 的 writeFileAtomic（异步、wx 独占
+   * 创建 + 随机后缀 + 符号链接安全，无 per-file fsync，对齐 DSH 基座标准）。
+   */
   atomicWrite(file: string, text: string): void {
     mkdirSync(dirname(file), { recursive: true })
     const tmp = `${file}.tmp-${process.pid}`

package/src/host/service.ts

@@ -28,8 +28,8 @@ export interface GroupChatService {
   subscribePush(push: () => void): () => void
   /** 设置停用时中止正在进行的群聊。 */
   stopAll(): void
-  /** 卸载/热重载：唤醒确认等待 + kill 子进程 → 同步最终 flush → 释放锁。 */
-  dispose(): void
+  /** 卸载/热重载：唤醒确认等待 + kill 子进程 → 异步最终 flush → 释放锁（cordis 会 await）。 */
+  dispose(): Promise<void>
 }
 
 /**
@@ -66,13 +66,13 @@ export function createGroupChatService(ctx: Context): GroupChatService {
         bus.touch()
       }
     },
-    dispose(): void {
+    dispose(): Promise<void> {
       core.run.stopping = true
       if (core.run.pendingConfirm) tools.wakeConfirm()
       tools.killChild()
       materials.disposeFileSearch()
       bus.dispose()
-      persist.release()
+      return persist.release()
     },
   }
 }

package/src/host/state.ts

@@ -8,9 +8,10 @@
 
 import { randomUUID } from 'node:crypto'
 import type { Context } from '@deepseek-ai/cordis'
-// 类型合并：ctx.llm / ctx.fs / ctx.workspaceRegistry（宿主面）
+// 类型合并：ctx.llm / ctx.fs / ctx.shell / ctx.workspaceRegistry（宿主面）
 import type {} from '@deepseek-ai/dsh-llm'
 import type {} from '@deepseek-ai/dsh-fs'
+import type {} from '@deepseek-ai/dsh-shell'
 import type {} from '@deepseek-ai/dsh-workspace'
 import type { Store } from './persistence/store.ts'
 import type { GroupRecord, LastCreated, MessageRecord, RoleRecord, RunState, SessionRecord } from '../core/types.ts'
@@ -36,6 +37,7 @@ export interface HostState {
   ctx: Context
   llm: Context['llm']
   fs: Context['fs']
+  shell: Context['shell']
   groups: Map<string, GroupRecord>
   sessions: Map<string, SessionRecord>
   roles: Map<string, RoleRecord>
@@ -59,11 +61,12 @@ export function createHostState(ctx: Context): HostState {
     ctx,
     llm: ctx.llm,
     fs: ctx.fs,
+    shell: ctx.shell,
     groups: new Map(),
     sessions: new Map(),
     roles: new Map(),
     messages: new Map(),
-    run: { running: false, sessionId: null, currentRoleId: null, partial: '', partialReasoning: '', stopping: false, queue: [], pendingConfirm: null, confirmSignal: null, childProc: null, finished: null, replaceMessageId: null },
+    run: { running: false, sessionId: null, currentRoleId: null, partial: '', partialReasoning: '', stopping: false, queue: [], pendingConfirm: null, confirmSignal: null, commandAbort: null, finished: null, replaceMessageId: null },
     store: null,
     revision: 1,
     idSeq: 1,

package/src/host/tools/tools.ts

@@ -1,11 +1,11 @@
 /**
  * 工具执行（TOOLS.md §2：沙箱 / §3：确认闸门）：read_file / list_dir /
  * run_command 三件套；realpath 硬边界 + 分隔符比较；run_command 按群组
- * 权限档位走逐条确认或直接执行。
+ * 权限档位走逐条确认或直接执行，经 `shell` 服务（ctx.shell 沙箱执行器）
+ * 以 per-call sandboxPolicy 收紧到群工作区。
  * @module dsh-group-chat/host/tools
  */
 
-import { spawn, type ChildProcess } from 'node:child_process'
 import { closeSync, openSync, readSync, readdirSync, realpathSync, statSync } from 'node:fs'
 import { isAbsolute, join, sep } from 'node:path'
 import { CMD_CAPTURE_MAX_BYTES, CMD_OUTPUT_MAX_CHARS, READ_FILE_MAX_BYTES, RUN_CMD_TIMEOUT_MS, TOOL_SCHEMAS } from '../../core/tools.ts'
@@ -28,7 +28,7 @@ export interface Tools {
 
 /** 创建工具面。 */
 export function createTools(core: HostState, touch: () => void): Tools {
-  const { run } = core
+  const { run, shell } = core
 
   /** realpath 硬边界：目标必须在群组工作区内（带分隔符比较，防 /ws/foo 放行 /ws/foobar）。 */
   const resolveInWorkspace = (root: string, rawPath: unknown): { ok: true, target: string } | { ok: false, error: string } => {
@@ -92,45 +92,40 @@ export function createTools(core: HostState, touch: () => void): Tools {
     }
   }
 
-  const runCommandTool = (root: string, command: string): Promise<{ status: 'ok' | 'error', output: string }> => new Promise((resolve) => {
-    let child: ChildProcess
+  /**
+   * 经 `shell` 服务执行命令（TOOLS.md §2）：cwd 与沙箱均收紧到群工作区根
+   * （workspace_write 档经 sandboxPolicy 强制；full_access 档对齐 DSH
+   * danger-full-access 语义免受限）。超时/中止由执行器 kill 进程并按首因
+   * 分类报告；runner 失效（如 SANDBOX_UNAVAILABLE）经 catch 报错不执行。
+   */
+  const runCommandTool = async (g: GroupRecord, root: string, command: string): Promise<{ status: 'ok' | 'error', output: string }> => {
+    const abort = new AbortController()
+    run.commandAbort = abort
     try {
-      child = spawn('bash', ['-c', command], { cwd: root })
+      const spec = shell.resolve({
+        command,
+        workdir: root,
+        timeoutMs: RUN_CMD_TIMEOUT_MS,
+        stdoutMaxBytes: CMD_CAPTURE_MAX_BYTES,
+        sandboxPolicy: g.permissionTier === 'full_access'
+          ? { mode: 'danger-full-access' as const, workspaceRoot: root }
+          : { mode: 'workspace-write' as const, workspaceRoot: root },
+        signal: abort.signal,
+      })
+      const r = await shell.run(spec)
+      let text = r.stdout.text + r.stderr.text
+      if (r.stdout.truncated || r.stderr.truncated) text += '\n[输出采集超限，已截断（保留末尾）]'
+      if (r.sandbox?.denied) text += '\n[沙箱拦截了越界的文件操作]'
+      if (r.timedOut) text += '\n[执行超时（' + Math.round(RUN_CMD_TIMEOUT_MS / 1000) + 's），已强制终止]'
+      if (r.exitCode !== 0 && r.exitCode !== null && !r.timedOut) text += '\n[退出码 ' + r.exitCode + ']'
+      if (text.length > CMD_OUTPUT_MAX_CHARS) text = text.slice(0, CMD_OUTPUT_MAX_CHARS) + '\n…(输出超长，已截断)'
+      return { status: r.exitCode === 0 ? 'ok' : 'error', output: text || '（无输出）' }
     } catch (e) {
-      resolve({ status: 'error', output: '无法启动命令：' + String((e && (e as Error).message) || e) })
-      return
-    }
-    run.childProc = child
-    let out = ''
-    let dropped = 0
-    let timedOut = false
-    const onChunk = (chunk: Buffer) => {
-      if (out.length < CMD_CAPTURE_MAX_BYTES) out += chunk.toString('utf8')
-      else dropped += chunk.length
-    }
-    child.stdout?.on('data', onChunk)
-    child.stderr?.on('data', onChunk)
-    const timer = setTimeout(() => {
-      timedOut = true
-      try {
-        child.kill('SIGKILL')
-      } catch {}
-    }, RUN_CMD_TIMEOUT_MS)
-    const finish = (result: { status: 'ok' | 'error', output: string }) => {
-      clearTimeout(timer)
-      if (run.childProc === child) run.childProc = null
-      resolve(result)
+      return { status: 'error', output: '无法启动命令：' + String((e && (e as Error).message) || e) }
+    } finally {
+      if (run.commandAbort === abort) run.commandAbort = null
     }
-    child.on('error', (e) => finish({ status: 'error', output: '执行失败：' + String((e && e.message) || e) }))
-    child.on('close', (code) => {
-      let text = out.length > CMD_CAPTURE_MAX_BYTES ? out.slice(0, CMD_CAPTURE_MAX_BYTES) : out
-      if (dropped > 0) text += '\n[输出采集超限，已丢弃 ' + dropped + ' 字节]'
-      if (timedOut) text += '\n[执行超时（' + Math.round(RUN_CMD_TIMEOUT_MS / 1000) + 's），已强制终止]'
-      if (code !== 0 && code !== null && !timedOut) text += '\n[退出码 ' + code + ']'
-      if (text.length > CMD_OUTPUT_MAX_CHARS) text = text.slice(0, CMD_OUTPUT_MAX_CHARS) + '\n…(输出超长，已截断)'
-      finish({ status: code === 0 ? 'ok' : 'error', output: text || '（无输出）' })
-    })
-  })
+  }
 
   /** run_command 确认闸门：置 pendingConfirm 后无限等待，confirmCommand/stop/dispose 唤醒。 */
   const requestConfirmation = (toolCallId: string, args: Record<string, unknown>): Promise<boolean> => new Promise((resolve) => {
@@ -151,11 +146,10 @@ export function createTools(core: HostState, touch: () => void): Tools {
   }
 
   const killChild = (): void => {
-    if (run.childProc) {
-      try {
-        run.childProc.kill('SIGKILL')
-      } catch {}
-    }
+    // 中止正在执行的命令：执行器收到 abort 信号后 kill 进程
+    try {
+      run.commandAbort?.abort()
+    } catch {}
   }
 
   const executeTool = async (g: GroupRecord, root: string, tc: { id: string, name: string, args: string }): Promise<ToolExecution> => {
@@ -175,9 +169,9 @@ export function createTools(core: HostState, touch: () => void): Tools {
         const allowed = await requestConfirmation(tc.id, args)
         if (run.stopping) res = { status: 'error', output: '对话已被用户停止，命令未执行' }
         else if (!allowed) res = { status: 'denied', output: '用户拒绝了这次命令执行' }
-        else res = await runCommandTool(root, String(args.command || ''))
+        else res = await runCommandTool(g, root, String(args.command || ''))
       } else {
-        res = await runCommandTool(root, String(args.command || ''))
+        res = await runCommandTool(g, root, String(args.command || ''))
       }
     } else {
       res = { status: 'error', output: '未知工具：' + tc.name }