agentworkshop 0.7.44 → 0.7.46

package/scripts/test-hitl-legacy-channel-auth.ts

@@ -0,0 +1,143 @@
+/**
+ * HITL 无持久化行时的遗留 Channel 授权回归测试:
+ *   pnpm exec tsx scripts/test-hitl-legacy-channel-auth.ts
+ */
+import { AppError } from '../server/utils/errors'
+import { configureHitlRuntime, getHitlRegistry, type HitlRuntimePort } from '../server/services/workshop/agents/hitl-registry'
+import { decideHitlRequest, registerHitlNativeDispatcher } from '../server/services/workshop/agents/hitl-decision'
+
+const legacyChannel = { id: 'legacy-channel', ownerUserId: null, approvalPolicy: 'any_member' }
+const claimedChannel = { id: 'claimed-channel', ownerUserId: 'u-owner', approvalPolicy: 'any_member' }
+const channels = new Map([
+  [legacyChannel.id, legacyChannel],
+  [claimedChannel.id, claimedChannel],
+])
+const members = new Set(['claimed-channel:u-member'])
+let runtime: HitlRuntimePort | null = null
+let approvalChecks = 0
+let legacyReadChecks = 0
+let nativeCalls = 0
+let failures = 0
+
+function check(name: string, ok: boolean, detail = ''): void {
+  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
+  if (!ok) failures += 1
+}
+
+async function captureError(fn: () => Promise<unknown>): Promise<{ status?: number, code?: string } | null> {
+  try {
+    await fn()
+    return null
+  }
+  catch (err) {
+    const error = err as { status?: number, code?: string }
+    return error
+  }
+}
+
+function register(id: string, channelId: string): void {
+  getHitlRegistry().register({
+    kind: 'codex-approval',
+    id,
+    agentId: `agent-${id}`,
+    channelId,
+    method: 'confirm',
+    title: 'authorization regression',
+    requestType: 'approval',
+  })
+}
+
+async function main(): Promise<void> {
+  configureHitlRuntime(() => runtime)
+  register('legacy-no-row', legacyChannel.id)
+  register('claimed-no-row', claimedChannel.id)
+
+  runtime = {
+    groupChat: {
+      hitl: {
+        find: () => undefined,
+        listNonTerminal: () => [],
+      },
+      members: { listActiveByChannel: () => [] },
+    },
+    notifyUser: () => ({ id: 'notification', inserted: true }),
+    listChannelsVisibleTo: () => [...channels.values()],
+    listChannelsForUser: userId => [...channels.values()].filter(channel => channel.ownerUserId === null || channel.ownerUserId === userId),
+    requireChannelMember: (channelId, user) => {
+      const channel = channels.get(channelId)
+      if (!channel) throw new AppError(404, 'NOT_FOUND', 'channel not found')
+      if (user.role !== 'admin' && channel.ownerUserId === null) throw new AppError(403, 'FORBIDDEN_LEGACY', 'legacy channel')
+      return channel
+    },
+    requireCanApprove: (channelId, user) => {
+      approvalChecks += 1
+      const channel = channels.get(channelId)
+      if (!channel) throw new AppError(404, 'NOT_FOUND', 'channel not found')
+      if (channel.ownerUserId === null) throw new AppError(403, 'FORBIDDEN_LEGACY', 'legacy channel requires claim')
+      if (channel.ownerUserId !== user.id && !(channel.approvalPolicy === 'any_member' && members.has(`${channelId}:${user.id}`))) {
+        throw new AppError(403, 'APPROVAL_FORBIDDEN', 'current approval policy denied')
+      }
+      return channel
+    },
+    getChannelForUser: (channelId, userId) => {
+      legacyReadChecks += 1
+      const channel = channels.get(channelId)
+      if (!channel || (channel.ownerUserId !== null && channel.ownerUserId !== userId)) {
+        throw new AppError(403, 'SCOPE_VIOLATION', 'channel not visible')
+      }
+      return channel
+    },
+    findChannelAgentById: () => undefined,
+    respondHarnessHitl: async () => {},
+  } as unknown as HitlRuntimePort
+
+  registerHitlNativeDispatcher('codex-approval', async () => {
+    nativeCalls += 1
+    return { via: 'test' }
+  })
+
+  const legacyError = await captureError(() => decideHitlRequest({
+    kind: 'codex-approval',
+    id: 'legacy-no-row',
+    user: { id: 'u-member', role: 'user' },
+    decision: { confirmed: true },
+  }))
+  check('无持久化行的 owner=NULL legacy channel 对普通登录用户 fail-closed',
+    legacyError?.status === 403 && legacyError.code === 'FORBIDDEN_LEGACY_APPROVAL', JSON.stringify(legacyError))
+  check('遗留请求被拒后仍 pending，且未调用旧只读守卫或原生批准',
+    getHitlRegistry().find('codex-approval', 'legacy-no-row')?.status === 'pending'
+    && legacyReadChecks === 0 && nativeCalls === 0,
+    `legacyRead=${legacyReadChecks}, approvalChecks=${approvalChecks}(审批守卫可被咨询,以拒为结论), native=${nativeCalls}`)
+
+  const claimedResult = await decideHitlRequest({
+    kind: 'codex-approval',
+    id: 'claimed-no-row',
+    user: { id: 'u-member', role: 'user' },
+    decision: { confirmed: true },
+  })
+  check('无行但已有显式 owner 与当前 any_member 资格时仍可决策',
+    claimedResult.status === 'approved' && !claimedResult.persisted && nativeCalls === 1)
+
+  runtime = null
+  register('no-auth-runtime', claimedChannel.id)
+  const unavailableError = await captureError(() => decideHitlRequest({
+    kind: 'codex-approval',
+    id: 'no-auth-runtime',
+    user: { id: 'u-member', role: 'user' },
+    decision: { confirmed: true },
+  }))
+  check('无持久化行且当前授权运行时缺失时拒绝，而非跳过授权',
+    unavailableError?.status === 503 && unavailableError.code === 'HITL_AUTH_UNAVAILABLE'
+    && getHitlRegistry().find('codex-approval', 'no-auth-runtime')?.status === 'pending'
+    && nativeCalls === 1, JSON.stringify(unavailableError))
+
+  registerHitlNativeDispatcher('codex-approval', null)
+  configureHitlRuntime(null)
+  console.log(failures === 0 ? '\n[hitl-legacy-channel-auth] 全部通过' : `\n[hitl-legacy-channel-auth] ${failures} 项失败`)
+  process.exit(failures === 0 ? 0 : 1)
+}
+
+main().catch((err) => {
+  console.error('[hitl-legacy-channel-auth] 测试异常终止:', err)
+  process.exit(1)
+})

package/scripts/test-lane-history-live.mjs

@@ -55,18 +55,41 @@ const leadId = ch.data.leadAgentId
 
 try {
   await api('POST', `/api/workshop/channels/${channelId}/activate`, { token })
+  // 该 channel 只有一个 mock lead:补一个 worker 承接子任务,并由 lead 发一条真实 a2a
+  // 消息 —— 子任务 assign 走信箱(不产生 a2a.message 帧),事件类型覆盖需要真实发送。
+  const w = await api('POST', `/api/workshop/channels/${channelId}/agents`, {
+    token,
+    body: { name: 'lane-worker', harness: 'mock', config: { delayMs: 200 } },
+  })
+  const members = await api('GET', `/api/workshop/channels/${channelId}/agents`, { token })
+  const leadToken = (members.data ?? []).find(m => m.id === leadId)?.token
+  if (leadToken && w.data?.id) {
+    await api('POST', '/api/workshop/a2a/send', {
+      token: leadToken,
+      body: { toAgentId: w.data.id, parts: [{ text: 'lane 历史覆盖检查:请确认收到' }] },
+    })
+  }
   const task = await api('POST', `/api/workshop/channels/${channelId}/tasks`, {
     token,
     body: { title: `lane-history-${tag}`, description: '验证历史持久化与按 agent 加载', mode: 'goal', modeConfig: { goalCriteria: '全部完成' } },
   })
   check('提交 goal 任务', task.code === 0 && task.data?.state === 'SUBMITTED', `state=${task.data?.state}`)
-  // 任务执行到 WORKING 即已产生足够事件(录制器落库);不依赖终态(与历史加载验证正交)
-  const enough = await waitUntil('事件落库', async () => {
-    const e = await api('GET', `/api/workshop/channels/${channelId}/events?limit=500`, { token })
-    return (e.data?.items ?? []).length >= 4 ? e.data.items : null
-  })
-  check('事件已持久化(WORKING 阶段)', enough.length >= 4, `events=${enough.length}`)
-  const items = enough
+  // 等待「事件类型覆盖」成型而非只等条数:任务派发是异步的(lead 回合 → 子任务 assign
+  // 消息 → a2a.message 帧),只按条数 4 判断会在消息帧到达前就取样(实测竞态)。
+  const COVER = ['a2a.message', 'agent.status', 'task.status']
+  let enough = null
+  try {
+    enough = await waitUntil('事件落库(覆盖消息/状态/任务三类)', async () => {
+      const e = await api('GET', `/api/workshop/channels/${channelId}/events?limit=500`, { token })
+      const items = e.data?.items ?? []
+      return items.length >= 4 && COVER.every(t => items.some(x => x.type === t)) ? items : null
+    }, 30_000)
+  }
+  catch {
+    // 超时不直接崩:下方断言会以 FAIL 形式如实报告缺哪类帧
+  }
+  const items = enough ?? (await api('GET', `/api/workshop/channels/${channelId}/events?limit=500`, { token })).data?.items ?? []
+  check('事件已持久化(WORKING 阶段)', items.length >= 4, `events=${items.length}`)
 
   // ── 1. 全量历史(items 已在上方取到)──
   const shapeOk = items.every(e => e.v === 1 && typeof e.seq === 'number' && e.type && e.at && e.channelId === channelId)

package/scripts/test-memory-vector.ts

@@ -12,6 +12,7 @@ import {
   createEnvEmbeddingProvider,
   createHashEmbeddingProvider,
 } from '../server/services/workshop/runtime/embedding-provider'
+import { invalidateRuntimeSettingsCache } from '../server/services/workshop/settings'
 
 let failures = 0
 function check(name: string, ok: boolean, detail = ''): void {
@@ -41,10 +42,19 @@ const savedKey = process.env.AW_MEMORY_EMBED_API_KEY
 delete process.env.AW_MEMORY_EMBED_BASE_URL
 delete process.env.AW_MEMORY_EMBED_MODEL
 delete process.env.AW_MEMORY_EMBED_API_KEY
+// settings 读取链进程内缓存 3s(settings.ts 的 TTL 缓存 / system-config 快照)。
+// 本测试直接改 process.env,必须显式失效缓存 —— 否则上一步的"未配置"快照会在
+// 3 秒内继续生效,provider 返回 null 而不是新配置的实例(实测:flaky 崩溃)。
+invalidateRuntimeSettingsCache()
 check('env 未配置返回 null(纯 FTS 降级)', createEnvEmbeddingProvider() === null)
 process.env.AW_MEMORY_EMBED_BASE_URL = 'http://127.0.0.1:1' // 立即拒绝,零等待
 process.env.AW_MEMORY_EMBED_MODEL = 'test-model'
+invalidateRuntimeSettingsCache()
 const breaker = createEnvEmbeddingProvider()!
+if (!breaker) {
+  console.log('  FAIL  env provider 未按配置构建(settings 缓存未失效?)')
+  failures += 1
+}
 for (let i = 0; i < 3; i++) await breaker.embed(['x']).catch(() => {})
 const cooled = await breaker.embed(['x']).then(() => false, (e: Error) => e.message.includes('冷却'))
 check('连续 3 次失败进入冷却熔断', cooled)

package/scripts/test-orchestration.ts

@@ -26,6 +26,7 @@ import { createMemoryRepo } from '../server/services/workshop/db/memory.repo'
 import { createChannelEventRepo } from '../server/services/workshop/db/channel-event.repo'
 import { createTeamRepo } from '../server/services/workshop/db/team.repo'
 import { createTeamMemberRepo } from '../server/services/workshop/db/team-member.repo'
+import { createUserRepo } from '../server/services/workshop/db/user.repo'
 import {
   createAgentChannelManager,
   type AgentChannelManager,
@@ -126,7 +127,7 @@ class SuperviseOnlyLead implements AgentInterface {
               kind: 'dispatch',
               parentTaskId: task.id,
               assigneeId: worker.agentId,
-              title: task.title,
+              title: `${task.title} — 子任务 ${decisions.filter(d => d.kind === 'dispatch' && d.parentTaskId === task.id).length + 1}`,
               description: task.description,
             })
           }
@@ -164,6 +165,7 @@ interface Harness {
 function setup(): Harness {
   const db = openWorkshopDb(':memory:')
   const repos: AllRepos = {
+    users: createUserRepo(db),
     channels: createChannelRepo(db),
     agents: createAgentRepo(db),
     channelAgents: createChannelAgentRepo(db),
@@ -356,7 +358,7 @@ async function testRealMockLeadFlow(h: Harness, loops: SchedulerLoop[], channels
   const main = await manager.submitChannelTask({
     channelId: team.channelId,
     title: '生产路径主任务',
-    description: '真实 mock lead 自动调度',
+    description: '[mock:complex] 真实 mock lead 自动调度并执行 worker 验收流程',
   })
 
   const done = await waitUntil(async () => {
@@ -389,6 +391,7 @@ async function main(): Promise<void> {
       db: db2,
       manager: createAgentChannelManager({
         repos: {
+          users: createUserRepo(db2),
           channels: createChannelRepo(db2),
           agents: createAgentRepo(db2),
           channelAgents: createChannelAgentRepo(db2),
@@ -407,6 +410,8 @@ async function main(): Promise<void> {
       repos: null as never,
     }
     await testRealMockLeadFlow(h2, loops, channels)
+    for (const loop of loops) loop.stop()
+    await h2.manager.shutdown()
     h2.db.close()
   }
   finally {

package/scripts/test-persistence-lazy.ts

@@ -175,7 +175,13 @@ async function testRestoreWithPending(): Promise<void> {
     const wTpl = await manager1.createAgent({ name: 'w', harness: 'mock', config: { delayMs: 200 } })
     await manager1.addAgentToChannel({ channelId, agentId: wTpl.id, role: 'worker' })
     // 提交一个任务但不完成(不等它完成就关闭)
-    const task = await manager1.submitChannelTask({ channelId, title: '未完成任务' })
+    //
+    // 用 `[mock:complex]` 强制 mock lead 委派给 worker(mock-agent 的显式委派开关)。
+    // 简单任务会被 mock lead 在**首个监督回合**直接 complete(设计行为:§10 Real OMP
+    // 「简单任务 Lead 直接完成」),而监督回合与 lead 的 assign 回合之间存在微任务竞态 ——
+    // 于是「100ms 后仍未完成」在简单任务上是不稳定的断言(实测随调度器先/后 tick 摆动)。
+    // 委派路径至少要经过 一次 lead 回合 + worker 200ms 回合,100ms 内必然非终态。
+    const task = await manager1.submitChannelTask({ channelId, title: '未完成任务 [mock:complex]' })
     // 等它被 dispatch 进入工作状态
     await sleep(100)
     check('关闭前有未完成任务', getEngine(manager1).get(task.id)?.state !== 'COMPLETED')

package/scripts/test-prompt-system.mjs

@@ -92,54 +92,80 @@ async function main() {
   check('3. 克隆实例携带模板 config(专长 prompt)', String(workerMeta?.config?.systemPromptPrefix ?? '').includes('markdown bullet points'))
 
   // ===== 4. 提交任务 + 终端观测注入 =====
+  // 必须显式要求分解:worker 只有在收到派发的子任务时才会起回合并打出 prompt 帧;
+  // 一步任务会被 lead 直接收口,worker 永不 spawn → 本测试的观测点为空。
   const task = await api('POST', `/api/workshop/channels/${channelId}/tasks`, {
     token,
     body: {
-      title: '撰写 v2.1 发布说明',
-      description: '基于以下变化撰写发布说明:新增深色主题、修复导出失败问题、性能提升约 30%。',
+      title: '[mock:complex] 撰写 v2.1 发布说明',
+      description: '基于以下变化撰写发布说明:新增深色主题、修复导出失败问题、性能提升约 30%。本任务必须分解并派发给 worker 执行,等待其交付后汇总收口。',
     },
   })
   const parentId = task.data.id
   check('4. 任务提交', task.code === 0)
 
   // 等 worker 进程 spawn,然后经终端镜像读取其回合并 prompt
-  const termWs = async () => {
+  // 终端镜像 WS:回合 prompt 是每条回合一次的 user 消息帧,原实现每 8s 只开 1.5s
+  // 窗口(≈19% 命中率)→ 必然偶发失败。改为**长连接 + 命中即返回**(WS 首帧重放环形
+  // 缓冲,窗口外已到达的帧同样可见)。
+  // 命中判据用 **'Scenario Brief'**(组合 prompt 首段)而非 'Your Assignment':镜像按
+  // TERM_FRAME_TEXT_PREVIEW_MAX=4000 截断,而 system-manual(3171B)之后的
+  // worker-workflow(含 'Your Assignment')必落在截断区外 —— 用它做判据永不命中。
+  // (实测:user 帧 len=4023,截断 4122 字,'Scenario Brief'@3 / 'Your Profile'@192 /
+  //  'Workshop System Manual'@1697 / 'complete_task'@2090 / 'Your Assignment'@-1)
+  const termWs = async (windowMs = 20_000) => {
     const t = await api('GET', `/api/workshop/channels/${channelId}/terminals`, { token })
     const worker = (t.data ?? []).find(x => x.agentId === workerId)
     if (!worker) return null
+    const wsBase = BASE.replace(/^http/, 'ws')
     return new Promise((resolve) => {
+      let settled = false
       const frames = []
-      const ws = new WebSocket(`ws://127.0.0.1:3101/api/system/monitor/terminal/ws?agentId=${workerId}&channelId=${channelId}&token=${token}`)
+      const finish = (value) => {
+        if (settled) return
+        settled = true
+        clearTimeout(timer)
+        try {
+          ws.close()
+        }
+        catch { /* 已关闭 */ }
+        resolve(value)
+      }
+      const ws = new WebSocket(`${wsBase}/api/system/monitor/terminal/ws?agentId=${workerId}&channelId=${channelId}&token=${token}`)
+      const timer = setTimeout(() => finish(null), windowMs)
       ws.onmessage = (ev) => {
         const m = JSON.parse(ev.data)
-        if (m.type === 'term.frames') frames.push(...m.frames)
+        if (m.type !== 'term.frames') return
+        frames.push(...m.frames)
+        const hit = m.frames.find(f => f.frame?.type === 'message_start' && f.frame?.role === 'user'
+          && String(f.frame?.text ?? '').includes('Scenario Brief'))
+        if (hit) finish(String(hit.frame.text))
       }
-      ws.onopen = () => setTimeout(() => {
-        ws.close()
-        resolve(frames)
-      }, 1500)
-      ws.onerror = () => resolve(null)
+      ws.onerror = () => finish(null)
     })
   }
+  // termWs 已改为「命中即返回 prompt 文本」,这里直接等它返回(总预算 300s)
   const promptFrames = await waitUntil('worker prompt 帧出现', async () => {
-    const frames = await termWs()
-    if (!frames) return null
-    const userMsg = frames.find(f => f.frame.type === 'message_start' && f.frame.role === 'user'
-      && String(f.frame.text ?? '').includes('Your Assignment'))
-    return userMsg ? String(userMsg.frame.text) : null
-  }, 300_000, 8000)
+    const hit = await termWs()
+    return hit ?? null
+  }, 300_000, 1_000)
 
   // ===== 五段式注入观测(直接证据) =====
+  check('4obs. 终端镜像观测到回合 user prompt 帧', promptFrames.length > 0, `镜像可见长度=${promptFrames.length}(截断上限 4000)`)
   check('4a. Scenario Brief 段注入(channel 场景)', promptFrames.includes('Scenario Brief') && promptFrames.includes('[REL-DONE]') && promptFrames.includes('不超过 100 字'))
   check('4b. Your Profile 段注入(模板专长)', promptFrames.includes('Your Profile') && promptFrames.includes('markdown bullet points'))
   check('4c. Workshop System Manual 段注入', promptFrames.includes('Workshop System Manual') && promptFrames.includes('complete_task'))
-  check('4d. 段序正确(场景 → 专长 → 手册 → 任务)', (() => {
+  // 段序:镜像只保留组合 prompt 的前 4000 字(system-manual 之后即被截断),因此对
+  // 截断区内可观测的段做严格序检查;'Your Assignment' 恰好可见时一并校验末段序。
+  // 任务段本身由 5a-5f 行为断言覆盖(交付内容必须同时满足场景规范与专长风格)。
+  const iAssign = promptFrames.indexOf('Your Assignment')
+  check('4d. 段序正确(场景 → 专长 → 手册 → [任务])', (() => {
     const iScenario = promptFrames.indexOf('Scenario Brief')
     const iProfile = promptFrames.indexOf('Your Profile')
     const iManual = promptFrames.indexOf('Workshop System Manual')
-    const iAssign = promptFrames.indexOf('Your Assignment')
-    return iScenario >= 0 && iScenario < iProfile && iProfile < iManual && iManual < iAssign
-  })())
+    const head = iScenario >= 0 && iScenario < iProfile && iProfile < iManual
+    return iAssign >= 0 ? head && iManual < iAssign : head
+  })(), `Your Assignment 可见=${iAssign >= 0}(超出镜像截断窗口属预期)`)
 
   // ===== 5. 交付验证 =====
   const final = await waitUntil('父任务终态', async () => {

package/scripts/test-route-reason.mjs

@@ -48,7 +48,9 @@ async function main() {
     token,
   })
   const worker = await api('POST', `/api/workshop/channels/${channelId}/agents`, {
-    body: { name: 'worker', harness: 'mock', role: 'worker' },
+    // 慢 worker:lead 会把父任务分解给 worker,子任务在测试窗口内保持 WORKING,
+    // 父任务因此停在非终态 —— MCP 手工 dispatch 才有合法前置状态。
+    body: { name: 'worker', harness: 'mock', role: 'worker', config: { delayMs: 60_000 } },
     token,
   })
   const leadToken = lead.data?.token
@@ -56,8 +58,13 @@ async function main() {
   check('lead 实例 token 下发(MCP caller)', Boolean(leadToken) && Boolean(workerId))
 
   // ── 父任务 + MCP dispatch 带 route_reason ──
+  // lead 用长 delay:父任务在 MCP 手工派发前必须保持非终态 —— 简单任务会被 mock lead
+  // 在首个监督回合直接收口,那时再 dispatch 只会拿到 TASK_TERMINAL。
   const task = await api('POST', `/api/workshop/channels/${channelId}/tasks`, {
-    body: { title: 'route-parent', description: 'mock parent for route reason check' },
+    body: {
+      title: '[mock:complex] route-parent',
+      description: '父任务必须分解为子任务并派发给 worker 执行(本条同时是 route_reason 检查的前置)。',
+    },
     token,
   })
   const parentId = task.data?.id