agentworkshop 0.7.37 → 0.7.38

package/scripts/.mimosa/hook-state/sess_aeaecb58-8833-4b83-b93c-050467d21e03.mtxwtxme-61028-1f4519fbc4.baseline/ffb4e3aa548cfdadabaa44ab599f9b6a3ca6288176a2cc7a4b2fc2a12b5fb848.source

@@ -0,0 +1,101 @@
+/**
+ * 动态记忆感知测试:按需抓取(recallRows scope 过滤/原文还原/touch)、
+ * 主动沉淀(save 私有/共享分流 + 共享域 dedupKey 命名空间)、
+ * 记忆引子(小预算 primer + 工具提示行)。
+ * 运行: npx tsx scripts/test-memory-dynamic.ts
+ */
+import type { DatabaseSync } from 'node:sqlite'
+import { openWorkshopDb } from '../server/services/workshop/db/database'
+import { createMemoryRepo, TEAM_AGENT_ID } from '../server/services/workshop/db/memory.repo'
+import { AgentMemory } from '../server/services/workshop/runtime/memory'
+
+let failures = 0
+function check(name: string, ok: boolean, detail = ''): void {
+  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
+  if (!ok) failures += 1
+}
+
+const db: DatabaseSync = openWorkshopDb(':memory:')
+const repo = createMemoryRepo(db)
+const seg = (s: string): string => s.replace(/([\u4e00-\u9fff])/g, ' $1 ')
+
+// 播种:a1 私有 × 2、a2 私有 × 1、team 公共 × 1、他 channel 的 team 行 × 1(隔离守卫)
+repo.upsert({ channelId: 'ch1', agentId: 'a1', kind: 'episodic-task', title: '网关限流方案', titleFts: seg('网关限流方案'), content: seg('最终采用令牌桶算法限流,阈值100qps'), importance: 0.8, taskId: 't1', dedupKey: 'task:t1' })
+repo.upsert({ channelId: 'ch1', agentId: 'a1', kind: 'episodic-task', title: '部署脚本草稿', titleFts: seg('部署脚本草稿'), content: seg('deploy.sh 需要先source env'), importance: 0.4, taskId: 't2', dedupKey: 'task:t2' })
+repo.upsert({ channelId: 'ch1', agentId: 'a2', kind: 'episodic-task', title: '他人限流笔记', titleFts: seg('他人限流笔记'), content: seg('a2自己的限流杂记'), importance: 0.8, taskId: 't3', dedupKey: 'task:t3' })
+repo.upsert({ channelId: 'ch1', agentId: TEAM_AGENT_ID, kind: 'semantic', title: 'channel 限流约定', titleFts: seg('channel 限流约定'), content: seg('全channel统一用令牌桶,禁用计数器'), importance: 0.9, taskId: null, dedupKey: 'conv:ratelimit' })
+repo.upsert({ channelId: 'ch2', agentId: TEAM_AGENT_ID, kind: 'semantic', title: '他channel限流约定', titleFts: seg('他channel限流约定'), content: seg('ch2专属公共记忆不应被ch1看到'), importance: 0.9, taskId: null, dedupKey: 'conv:other' })
+
+const memA1 = new AgentMemory(repo, { channelId: 'ch1', agentId: 'a1' })
+
+console.log('--- 按需抓取 recallRows ---')
+{
+  const auto = await memA1.recallRows('限流 令牌桶')
+  check('auto 域命中本人 + 公共记忆', auto.some(s => s.title === '网关限流方案') && auto.some(s => s.title === 'channel 限流约定'), JSON.stringify(auto.map(s => s.title)))
+  check('auto 域不含他人私有记忆', auto.every(s => s.title !== '他人限流笔记'))
+  check('auto 域不含他 channel 公共记忆', auto.every(s => s.title !== '他channel限流约定'))
+  check('source 标注 private/shared', auto.some(s => s.source === 'private') && auto.some(s => s.source === 'shared'))
+  const own = auto.find(s => s.title === '网关限流方案')
+  check('content 还原为未切分原文', own !== undefined && !/\s/.test(own.content.slice(0, 4)) && own.content.includes('令牌桶'), own?.content.slice(0, 20))
+  check('返回综合分 score', auto.every(s => typeof s.score === 'number' && s.score > 0))
+
+  const sharedOnly = await memA1.recallRows('限流', { scope: 'shared' })
+  check('shared 域仅公共记忆', sharedOnly.length > 0 && sharedOnly.every(s => s.source === 'shared'), JSON.stringify(sharedOnly.map(s => s.title)))
+  check('shared 域严格本 channel', sharedOnly.every(s => s.title !== '他channel限流约定'))
+
+  const privOnly = await memA1.recallRows('限流', { scope: 'private' })
+  check('private 域仅本人记忆', privOnly.length > 0 && privOnly.every(s => s.source === 'private'), JSON.stringify(privOnly.map(s => s.title)))
+
+  const before = repo.listByAgent('a1', 10).find(r => r.title === '网关限流方案')!.accessCount
+  await memA1.recallRows('网关 限流')
+  const after = repo.listByAgent('a1', 10).find(r => r.title === '网关限流方案')!.accessCount
+  check('recallRows 触发 touch(强化后续排序)', after === before + 1, `before=${before} after=${after}`)
+
+  // scope 域内完全无记忆才真正返回空(全新 channel;有记忆时弱命中/时近兜底会返回行,by design)
+  const none = await new AgentMemory(repo, { channelId: 'ch-empty', agentId: 'nobody' }).recallRows('完全不存在的关键词xyzq')
+  check('无命中返回空数组(无记忆 agent)', Array.isArray(none) && none.length === 0)
+  const fallback = await memA1.recallRows('完全不存在的关键词xyzq')
+  check('FTS 无命中走时近兜底(有记忆 agent 返回最近行)', fallback.length > 0, JSON.stringify(fallback.map(s => s.title)))
+}
+
+console.log('\n--- 主动沉淀 save(私有/共享分流)---')
+{
+  const priv = await memA1.save({ title: 'SQLite 并发写坑', content: '并发写会 SQLITE_BUSY,须串行化写入', scope: 'private', dedupKey: 'note:sqlite' })
+  check('私有沉淀落入本人域', repo.findByAgentDedup('ch1', 'a1', 'note:sqlite') !== null && priv.scope === 'private')
+
+  const shared = await memA1.save({ title: '限流阈值结论', content: '全队统一令牌桶阈值100qps', scope: 'shared', dedupKey: 'conv:threshold' })
+  const teamRow = repo.findByAgentDedup('ch1', TEAM_AGENT_ID, `agent:a1:conv:threshold`)
+  check('共享沉淀落入 team 公共域(来源命名空间 dedupKey)', teamRow !== null && shared.dedupKey === 'agent:a1:conv:threshold')
+
+  // 同 raw key 不同 agent:命名空间隔离互不覆盖
+  const memA2 = new AgentMemory(repo, { channelId: 'ch1', agentId: 'a2' })
+  await memA2.save({ title: 'a2 的阈值结论', content: 'a2认为阈值应按服务分级', scope: 'shared', dedupKey: 'conv:threshold' })
+  const teamRows = repo.listByAgentChannel('ch1', TEAM_AGENT_ID, 100).filter(r => r.content.includes('阈值') || r.title.includes('阈值'))
+  check('多 agent 同 raw key 共享沉淀互不覆盖', repo.findByAgentDedup('ch1', TEAM_AGENT_ID, 'agent:a1:conv:threshold') !== null && repo.findByAgentDedup('ch1', TEAM_AGENT_ID, 'agent:a2:conv:threshold') !== null, `rows=${teamRows.length}`)
+
+  // 共享沉淀即时对全员可检索
+  const a2sees = await memA2.recallRows('阈值 令牌桶', { scope: 'shared' })
+  check('共享沉淀对其他 agent 即时可检索', a2sees.some(s => s.title === '限流阈值结论'), JSON.stringify(a2sees.map(s => s.title)))
+
+  // 稳定 dedupKey 幂等刷新不重复
+  await memA1.save({ title: '限流阈值结论', content: '修订:阈值升到200qps', scope: 'shared', dedupKey: 'conv:threshold' })
+  const count = repo.listByAgentChannel('ch1', TEAM_AGENT_ID, 100).filter(r => r.dedupKey === undefined && r.title === '限流阈值结论').length
+  const refreshed = repo.listByAgentChannel('ch1', TEAM_AGENT_ID, 100).some(r => r.title === '限流阈值结论')
+  check('稳定 dedupKey 幂等刷新', refreshed && count <= 1)
+}
+
+console.log('\n--- 记忆引子 primer(小预算注入)---')
+{
+  const block = await memA1.recall('限流 令牌桶 部署', { touch: false })
+  check('primer 返回记忆块', block !== null)
+  check('primer 含按需抓取工具提示', block !== null && block.includes('search_memory'), block?.slice(-80))
+  // v2 三层注入:L0 简报(save(shared) 后自动存在)+ L1 引子 + 提示,同在 300 tok 引子预算 + 500 tok 总预算内
+  check('primer 含 L0 会话简报', block !== null && block.includes('会话简报'))
+  check('primer 小预算(行数受限)', block !== null && block.split('\n').length < 16, `lines=${block?.split('\n').length}`)
+
+  const memTiny = new AgentMemory(repo, { channelId: 'ch1', agentId: 'a1', budgetTokens: 5 })
+  check('极小预算 primer 无行则 null', (await memTiny.recall('限流')) === null)
+}
+
+console.log(failures === 0 ? '\nALL PASS' : `\n${failures} FAILED`)
+process.exit(failures === 0 ? 0 : 1)

package/scripts/test-plugin-hardening.mjs

@@ -46,5 +46,37 @@ console.log('\n━━━ 2. 路由表按插件卸下(P0-1 回滚所需) ━━
   check('unregisterPlugin 幂等(再调返回 0)', t.unregisterPlugin('alpha') === 0)
 }
 
+console.log('\n━━━ 3. 稳定性护栏的严重性判定(哪类异常不该退进程) ━━━')
+{
+  const { classifyFatalCandidate } = await import('../server/utils/stability-severity.ts')
+  const err = (code, message = 'boom') => Object.assign(new Error(message), { code })
+
+  // 外部设备不可达 → 不退进程。实测事故:一台 Modbus TCP 设备未启动
+  // (connect ECONNREFUSED 127.0.0.1:1502)使整个生产实例 exit 1。
+  check('ECONNREFUSED(设备未启动)→ upstream', classifyFatalCandidate(err('ECONNREFUSED')) === 'upstream')
+  check('ENOTFOUND(DNS 解析失败)→ upstream', classifyFatalCandidate(err('ENOTFOUND')) === 'upstream')
+  check('EHOSTUNREACH → upstream', classifyFatalCandidate(err('EHOSTUNREACH')) === 'upstream')
+  check('ENETUNREACH → upstream', classifyFatalCandidate(err('ENETUNREACH')) === 'upstream')
+  check('undici UND_ERR_CONNECT_TIMEOUT → upstream', classifyFatalCandidate(err('UND_ERR_CONNECT_TIMEOUT')) === 'upstream')
+  check('无 code 但 message 带 ECONNREFUSED → upstream',
+    classifyFatalCandidate(new Error('connect ECONNREFUSED 127.0.0.1:1502')) === 'upstream')
+
+  // 其余既有分级不得回退
+  check('ECONNRESET(客户端硬断)→ socket', classifyFatalCandidate(err('ECONNRESET')) === 'socket')
+  check('EPIPE → socket', classifyFatalCandidate(err('EPIPE')) === 'socket')
+  check('SQLITE_BUSY → db-busy', classifyFatalCandidate(err('SQLITE_BUSY')) === 'db-busy')
+  check('database is locked(无 code)→ db-busy', classifyFatalCandidate(new Error('database is locked')) === 'db-busy')
+  check('omp API 4xx → engine', classifyFatalCandidate(new Error('omp API 500: upstream failed')) === 'engine')
+
+  // fail-fast 语义必须保住:真实缺陷仍要退进程
+  check('密钥校验失败 → fatal(安全插件 fail-fast 依赖)', classifyFatalCandidate(new Error('生产环境必须设置 NUXT_SESSION_PASSWORD')) === 'fatal')
+  check('任意未分类异常 → fatal', classifyFatalCandidate(new Error('unexpected token in JSON at position 0')) === 'fatal')
+  check('null → fatal(不放过未知形态)', classifyFatalCandidate(null) === 'fatal')
+  check('非 Error 值(字符串)→ fatal', classifyFatalCandidate('something odd') === 'fatal')
+  // 引擎名只允许出现在首行:stack 里偶然含引擎名不得把真实错误降级
+  check('引擎名仅在 stack 中 → 不降级',
+    classifyFatalCandidate(Object.assign(new Error('TypeError: x is not a function'), { stack: 'TypeError: x is not a function\n  at omp API (x.ts:1)' })) === 'fatal')
+}
+
 console.log(`\n━━━ 结果:${pass} passed, ${fail} failed ━━━\n`)
 process.exit(fail === 0 ? 0 : 1)

package/server/plugins/dev-stability-guard.ts

@@ -1,63 +1,40 @@
-/**
- * Server 稳定性护栏:浏览器断开(WS/keep-alive socket 硬断)产生 ECONNRESET/EPIPE
- * 类异步异常 —— Node 默认策略直接击穿进程,拖垮所有并发调试/运行会话。
- *
- * 严重性过滤(关键设计):只抑制 socket 级断连噪声;其余异常保留致命语义
- * (记日志后按非零码退出)—— 安全插件的 fail-fast(如生产密钥校验失败拒绝启动)
- * 依赖异常中止进程,绝不能被护栏吞掉。
- */
-const SOCKET_NOISE = /ECONNRESET|EPIPE|ECONNABORTED|ETIMEDOUT|ERR_STREAM_PREMATURE_CLOSE|ERR_STREAM_WRITE_AFTER_END/
-// SQLite 忙/锁(hardening ST-1):多写竞争的瞬态错误,记录并继续;
-// 真正的库损坏/磁盘错误不经此路径,仍走致命语义。
-const SQLITE_BUSY = /SQLITE_BUSY|SQLITE_LOCKED|database is locked/i
-// Agent 引擎边界错误(harness 容错):opencode/omp/codex/dsh 等外部引擎 RPC 失败
-// (HTTP 4xx/5xx、连接拒绝)只影响对应 agent 会话,应降级重试而非退进程 ——
-// 服务端同时承载 DAQ 数采/DCW 写控,引擎故障带走监控平台属于可用性事故。
-const ENGINE_BOUNDARY = /\b(opencode|omp|codex|dsh) API\b/i
-
-function isSocketNoise(reason: unknown): boolean {
-  if (reason == null) return false
-  const err = reason as NodeJS.ErrnoException
-  // code 命中即噪声(经典 errno 形态)
-  if (typeof err.code === 'string' && SOCKET_NOISE.test(err.code)) return true
-  // undici 等包装错误:code 可能是 UND_ERR_*/undefined,但 message/stack 仍带
-  // "read ECONNRESET" 文本 —— 全文兜底再测一次(四引擎并发下 keep-alive socket
-  // 复位是高频瞬态,不可判死进程)
-  return SOCKET_NOISE.test(describe(reason))
-}
-
-function describe(reason: unknown): string {
-  return reason instanceof Error
-    ? `${reason.message}\n${reason.stack?.slice(0, 600) ?? ''}`
-    : String(reason)
-}
-
-export default defineNitroPlugin(() => {
-  const isTransientDbBusy = (reason: unknown): boolean => SQLITE_BUSY.test(describe(reason))
-  const isEngineBoundary = (reason: unknown): boolean => ENGINE_BOUNDARY.test(describe(reason).split('\n')[0] ?? '')
-  let engineFaults = 0
-  const onFatalCandidate = (kind: string, reason: unknown): void => {
-    if (isSocketNoise(reason)) {
-      console.warn(`[stability-guard] socket noise suppressed: ${describe(reason).slice(0, 120)}`)
-      return
-    }
-    if (isTransientDbBusy(reason)) {
-      console.warn(`[stability-guard] sqlite busy(瞬态,不退出): ${describe(reason).slice(0, 120)}`)
-      return
-    }
-    if (isEngineBoundary(reason)) {
-      engineFaults += 1
-      console.error(`[stability-guard] 引擎边界错误(累计 ${engineFaults},不退出): ${describe(reason).slice(0, 400)}`)
-      return
-    }
-    console.error(`[stability-guard] fatal ${kind}, exiting:\n${describe(reason)}`)
-    process.exit(1)
-  }
-  process.on('unhandledRejection', (reason) => {
-    onFatalCandidate('unhandledRejection', reason)
-  })
-  process.on('uncaughtException', (err) => {
-    onFatalCandidate('uncaughtException', err)
-  })
-  console.warn('[stability-guard] armed (socket 断连/sqlite 瞬态忙/引擎边界错误 → 记录继续;其余真实错误 → exit 1)')
-})
+/**
+ * Server 稳定性护栏:浏览器断开(WS/keep-alive socket 硬断)产生 ECONNRESET/EPIPE
+ * 类异步异常 —— Node 默认策略直接击穿进程,拖垮所有并发调试/运行会话。
+ *
+ * 严重性判定集中在 `server/utils/stability-severity.ts`(可被纯 node 回归测试直接断言):
+ * socket 断连 / SQLite 瞬态忙 / 外部设备不可达 / Agent 引擎边界 → 记录并继续;
+ * 其余判为 fatal,记日志后按非零码退出 —— 安全插件的 fail-fast(如生产密钥校验
+ * 失败拒绝启动)依赖异常中止进程,绝不能被护栏吞掉。
+ *
+ * "外部设备不可达"是**运维常态**(设备下电、模拟器未启、容器重启):
+ * 曾实测到一台 Modbus TCP 设备未启动(`connect ECONNREFUSED 127.0.0.1:1502`)
+ * 使 unhandledRejection 走到 fatal 分支,整个生产实例 exit 1 ——
+ * 数采/数控/数字孪生全平台被一台设备带走,属可用性事故。
+ */
+import { classifyFatalCandidate, describeReason } from '../utils/stability-severity'
+
+export default defineNitroPlugin(() => {
+  // 'db-busy' 必须引号 → 按 @stylistic/quote-props 的 consistent 口径,同对象内全部加引号
+  const counts: Record<string, number> = { 'socket': 0, 'db-busy': 0, 'upstream': 0, 'engine': 0 }
+  const onFatalCandidate = (kind: string, reason: unknown): void => {
+    const severity = classifyFatalCandidate(reason)
+    if (severity === 'fatal') {
+      console.error(`[stability-guard] fatal ${kind}, exiting:\n${describeReason(reason)}`)
+      process.exit(1)
+    }
+    counts[severity] += 1
+    const line = `[stability-guard] ${severity}(累计 ${counts[severity]},不退出): ${describeReason(reason).slice(0, 200).replace(/\n/g, ' ')}`
+    // 外部设备不可达与引擎边界属"要有人知道"的信号 → error;其余瞬态噪声 → warn
+    if (severity === 'upstream' || severity === 'engine') console.error(line)
+    else console.warn(line)
+  }
+
+  process.on('unhandledRejection', (reason) => {
+    onFatalCandidate('unhandledRejection', reason)
+  })
+  process.on('uncaughtException', (err) => {
+    onFatalCandidate('uncaughtException', err)
+  })
+  console.warn('[stability-guard] armed (socket 断连/sqlite 瞬态忙/外部设备不可达/引擎边界错误 → 记录继续;其余真实错误 → exit 1)')
+})

package/server/utils/stability-severity.ts

@@ -0,0 +1,66 @@
+/**
+ * 致命异常严重性判定(稳定性护栏的唯一判据来源)。
+ *
+ * 为什么独立成文件:判定逻辑必须可被 **纯 node 回归测试** 直接加载断言。
+ * 放在 `server/plugins/dev-stability-guard.ts` 里就只能靠起真实服务观察,
+ * 而"哪类异常该退进程"恰恰是最不该靠观察来确认的一类逻辑。
+ *
+ * 四级严重性,只有 `fatal` 会退进程:
+ *
+ *  1. `socket`   —— 浏览器/客户端硬断(WS、keep-alive)。最高频的瞬态噪声,
+ *                   Node 默认策略会直接击穿进程,从而拖垮所有并发会话。
+ *  2. `db-busy`  —— SQLite 忙/锁。多写竞争的瞬态错误,应重试而非退出。
+ *  3. `upstream` —— **外部设备/上游服务不可达**:ECONNREFUSED / ENOTFOUND /
+ *                   EHOSTUNREACH / ENETUNREACH / 连接超时。
+ *                   这是运维常态(设备下电、模拟器未启、容器重启),
+ *                   绝不能让"某一台设备没开"带走整个监控平台 ——
+ *                   DAQ 驱动本身把这类失败记为节点 lastError 并继续轮询,
+ *                   护栏再补一刀 exit 1 就构成可用性事故。
+ *                   ⚠️ 与"连上了但业务失败"区分:后者不在此列,仍走 fatal。
+ *  4. `engine`   —— Agent 引擎边界错误(opencode/omp/codex/dsh 的 RPC 失败)。
+ *                   只影响对应 agent 会话,服务端同时承载数采/数控,不可退进程。
+ *
+ * 其余一律 `fatal`:安全插件的 fail-fast(如生产密钥校验失败拒绝启动)依赖异常
+ * 中止进程,绝不能被护栏吞掉。
+ */
+
+/** socket 级断连噪声 */
+export const SOCKET_NOISE = /ECONNRESET|EPIPE|ECONNABORTED|ETIMEDOUT|ERR_STREAM_PREMATURE_CLOSE|ERR_STREAM_WRITE_AFTER_END/
+
+/** 外部设备/上游不可达(运维常态,非程序缺陷) */
+export const UPSTREAM_UNREACHABLE = /ECONNREFUSED|ENOTFOUND|EHOSTUNREACH|ENETUNREACH|ERR_SOCKET_CONNECTION_TIMEOUT|UND_ERR_CONNECT_TIMEOUT/
+
+/** SQLite 忙/锁(hardening ST-1) */
+export const SQLITE_BUSY = /SQLITE_BUSY|SQLITE_LOCKED|database is locked/i
+
+/** Agent 引擎边界错误(harness 容错) */
+export const ENGINE_BOUNDARY = /\b(opencode|omp|codex|dsh) API\b/i
+
+export type FatalSeverity = 'socket' | 'db-busy' | 'upstream' | 'engine' | 'fatal'
+
+/** 错误→可读文本;Error 取 message + 截断 stack,其余 String() */
+export function describeReason(reason: unknown): string {
+  return reason instanceof Error
+    ? `${reason.message}\n${reason.stack?.slice(0, 600) ?? ''}`
+    : String(reason)
+}
+
+/**
+ * 判定一次"致命候选"的真实严重性。
+ * 命中顺序即优先级:code 字段优先(经典 errno),再全文兜底
+ * (undici 等包装错误 code 可能是 UND_ERR_*,但 message/stack 仍带原文)。
+ */
+export function classifyFatalCandidate(reason: unknown): FatalSeverity {
+  if (reason == null) return 'fatal'
+  const err = reason as NodeJS.ErrnoException
+  const code = typeof err.code === 'string' ? err.code : ''
+  const text = `${code}\n${describeReason(reason)}`
+
+  if (SOCKET_NOISE.test(text)) return 'socket'
+  if (SQLITE_BUSY.test(text)) return 'db-busy'
+  if (UPSTREAM_UNREACHABLE.test(text)) return 'upstream'
+  // 引擎边界只看首行:避免 stack 里偶然出现的引擎名把真实错误降级
+  const head = describeReason(reason).split('\n')[0] ?? ''
+  if (ENGINE_BOUNDARY.test(head)) return 'engine'
+  return 'fatal'
+}

package/.output/public/_nuxt/builds/meta/a66fdef7-dcfd-453b-b1f6-543c7dfd98d5.json

@@ -1 +0,0 @@
-{"id":"a66fdef7-dcfd-453b-b1f6-543c7dfd98d5","timestamp":1789185561795,"prerendered":[]}