@restregular/dsh-memory 0.35.1 → 0.35.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md CHANGED
@@ -2,6 +2,13 @@
2
2
 
3
3
  本项目的版本记录。安装 id 与 npm 版本一一对应。
4
4
 
5
+ ## 0.35.2 — 修复「未批准的新脚本无法试跑」:试跑改按 id 精确执行
6
+
7
+ - **问题(再次实机验证发现)**:技能 `memory-hook-scripts` 的上手流程第一步就是「先 `memory_hooks run` 试跑样例,再上线」。但 0.35.0/0.35.1 的 `run` 走的是 `runHooks(phase, ...)`,而 `runHooks` 会在 `HookStore.forRun()` 里过滤掉**未批准**的钩子(审批门禁放在存储层是对的),于是刚保存、还没批准的新脚本试跑时永远报「脚本没有命中这次输入(作用域/类型过滤把它排除了)」—— 实际上是审批门禁挡的,报错还说错了原因。流程直接走不通。
8
+ - **修法**:新增 `runHookTrial(id, input)` —— 按 id 精确跑**指定的那一条**,绕过审批门禁,且不记统计(试跑不是真实运行)。它不写记忆、不改数据,只是把脚本跑一遍拿返回值,所以绕过门禁是安全的;真实运行(保存前 / 保存后 / 注入前)仍走原来的审批门禁。`memory_hooks run` 与面板「试跑」都改用它,不再用 phase+scope/kind 二次过滤。
9
+ - **附带修复**:`memory_save` 的结果渲染此前忽略了 `hook` 字段,带 `hookCode` 保存后只说「已保存记忆」,Agent 不知道脚本挂没挂上、是不是还在等批准。现在回传「随附规则代码 <id>(<时机>):已获批准 / 用户拒绝·不会运行 / 等待批准超时·不会运行 / 当前环境无法审批·不会运行」。
10
+ - 回归守卫:`bundled-skills.test.ts` 加两条(run 走 runHookTrial、memory_save 渲染回传 hook),`hooks.test.ts` 加两条(未批准也能按 id 精确试跑且不记统计、不存在的 id 返回空)。全套 638 tests / 637 pass / 1 skipped。
11
+
5
12
  ## 0.35.1 — 修复 0.35.0 实机验证发现的两个问题
6
13
 
7
14
  - **问题 1:随包技能 `memory-hook-scripts` 加载不到**。两个工具的描述都引导 Agent 用 `skill` 工具加载它,但实机 `skill("memory-hook-scripts")` 报 unknown。根因是冷启动丢注册:`mountBundledSkills` 在 apply 里用 `ctx.get('skills')` 一次性取样,而 `skills` 服务由宿主核心提供、常晚于本插件 apply 就绪 —— 取到 undefined 且不会重试,技能永久消失(与 0.8.x 那次插件冷启动丢注册同一个坑)。改为在 apply 里用 `ctx.inject(['skills'], scope => mountBundledSkills(scope))` 等服务就绪后再挂,且放在独立 inject 回调里,不把整条 entry 拖成 PENDING。
package/lib/panel.js CHANGED
@@ -1297,13 +1297,14 @@ async function handle(ctx, routePath, req, res) {
1297
1297
  }
1298
1298
 
1299
1299
  if (action === 'run') {
1300
- if (typeof memory.runHooks !== 'function') throw new ApiError(501, 'NOT_SUPPORTED', 'provider 未提供记忆钩子试跑接口')
1300
+ if (typeof memory.runHookTrial !== 'function') throw new ApiError(501, 'NOT_SUPPORTED', 'provider 未提供记忆钩子试跑接口(请升级 @restregular/dsh-memory)')
1301
1301
  const id = typeof body.id === 'string' ? body.id : ''
1302
1302
  const content = typeof body.content === 'string' ? body.content : ''
1303
1303
  if (content.trim() === '') throw new ApiError(400, 'HOOK_CONTENT_REQUIRED', 'content 不能为空(试跑要一段样例正文)')
1304
1304
  const hook = typeof memory.getHook === 'function' ? memory.getHook(id) : undefined
1305
1305
  if (hook === undefined) throw new ApiError(404, 'HOOK_NOT_FOUND', '没有找到这个钩子')
1306
- const outcomes = memory.runHooks(hook.phase, {
1306
+ // 0.35.2:按 id 精确试跑、绕过审批门禁 —— 新脚本未批准时也要能先看判断结果。
1307
+ const outcomes = memory.runHookTrial(id, {
1307
1308
  memory: {
1308
1309
  scope: hook.scopes[0] ?? 'global',
1309
1310
  kind: hook.kinds[0] ?? 'rule',
@@ -1313,7 +1314,7 @@ async function handle(ctx, routePath, req, res) {
1313
1314
  },
1314
1315
  tool: 'panel',
1315
1316
  })
1316
- writeJson(res, { ok: true, value: { outcomes: outcomes.filter((item) => item.hook.id === hook.id) } })
1317
+ writeJson(res, { ok: true, value: { outcomes } })
1317
1318
  return
1318
1319
  }
1319
1320
 
@@ -430,6 +430,11 @@ export class CordisMemoryService extends Service {
430
430
  return this.impl.runHooks(phase, input)
431
431
  }
432
432
 
433
+ /** 试跑指定钩子(绕过审批门禁,不写记忆、不记统计)。 */
434
+ runHookTrial(id , input ) {
435
+ return this.impl.runHookTrial(id, input)
436
+ }
437
+
433
438
  parseForInject(records , sessionId ) {
434
439
  return this.impl.parseForInject(records, sessionId)
435
440
  }
@@ -416,13 +416,13 @@ export class HookStore {
416
416
  * 但**永远不会被执行**。把闸门放在存储层而不是各个调用点,是因为调用点有四个
417
417
  * (保存前 / 保存后 / 注入前 / 试跑),漏一个就是一条绕过审批的路径。
418
418
  */
419
- forRun(phase , target , settings ) {
419
+ forRun(phase , target , settings , ignoreApproval = false) {
420
420
  this.load()
421
421
  return this.hooks.filter((hook) =>
422
422
  hook.enabled
423
423
  && hook.phase === phase
424
424
  && hookApplies(hook, target)
425
- && !hookNeedsApproval(hook, settings))
425
+ && (ignoreApproval || !hookNeedsApproval(hook, settings)))
426
426
  }
427
427
 
428
428
  save(input , settings ) {
@@ -547,10 +547,16 @@ export function runHooks(
547
547
  phase ,
548
548
  input ,
549
549
  settings ,
550
+ options = {},
550
551
  ) {
551
552
  if (!settings.enabled) return []
552
553
  const out = []
553
- for (const hook of store.forRun(phase, { scope: input.memory.scope, kind: input.memory.kind }, settings)) {
554
+ for (const hook of store.forRun(
555
+ phase,
556
+ { scope: input.memory.scope, kind: input.memory.kind },
557
+ settings,
558
+ options.ignoreApproval === true,
559
+ )) {
554
560
  const started = Date.now()
555
561
  const result = runHookCode(hook.code, phase, input, settings)
556
562
  const crashed = result.error !== undefined
@@ -53,6 +53,7 @@ import {
53
53
  describeOutcomes,
54
54
  hashHookCode,
55
55
  hookNeedsApproval,
56
+ runHookCode,
56
57
  runHooks,
57
58
 
58
59
 
@@ -1051,11 +1052,36 @@ export class LocalMemoryService {
1051
1052
  return answer.outcome === 'timeout' ? 'timeout' : answer.outcome === 'unavailable' ? 'unavailable' : 'rejected'
1052
1053
  }
1053
1054
 
1054
- /** 真正跑一批钩子(工具 / 注入共用)。 */
1055
+ /** 真正跑一批钩子(工具 / 注入共用)。未批准的钩子不会执行。 */
1055
1056
  runHooks(phase , input ) {
1056
1057
  return runHooks(this.hooks, phase, input, this.hookSettings())
1057
1058
  }
1058
1059
 
1060
+ /**
1061
+ * 试跑指定的一条钩子(memory_hooks run / 面板试跑)。
1062
+ *
1063
+ * 与 runHooks 唯一的区别是**绕过审批门禁**:新写的脚本还没批准时必须能先看判断
1064
+ * 结果,否则技能里"先 run 试跑再上线"的流程根本走不通。试跑不产生副作用 ——
1065
+ * 不写记忆、不改数据,只是把脚本跑一遍拿返回值;统计也不记(试跑不是真实运行)。
1066
+ */
1067
+ runHookTrial(id , input ) {
1068
+ const hook = this.hooks.get(id)
1069
+ if (hook === undefined) return []
1070
+ const started = Date.now()
1071
+ const result = runHookCode(hook.code, hook.phase, input, this.hookSettings())
1072
+ const crashed = result.error !== undefined
1073
+ return [{
1074
+ hook: { id: hook.id, name: hook.name, phase: hook.phase },
1075
+ ok: crashed ? true : result.ok,
1076
+ durationMs: Date.now() - started,
1077
+ ...(result.message !== undefined ? { message: result.message } : {}),
1078
+ ...(result.content !== undefined ? { content: result.content } : {}),
1079
+ ...(result.drop === true ? { drop: true } : {}),
1080
+ ...(crashed ? { error: result.error } : {}),
1081
+ ...(result.logs.length > 0 ? { logs: result.logs.slice(0, 20) } : {}),
1082
+ }]
1083
+ }
1084
+
1059
1085
  /**
1060
1086
  * 注入前解析:把一批记录按 before-inject 钩子处理一遍。
1061
1087
  *
@@ -138,9 +138,25 @@ export function apply(ctx , config = {}) {
138
138
 
139
139
  register(tools.memory_save, (value, _args, exec) => {
140
140
  const agent = (exec )?.agent
141
- return value.deduped
141
+ const head = value.deduped
142
142
  ? `已更新既有记忆(内容相同,去重):${value.id} @ ${renderScope(value.scope, agent)}`
143
143
  : `已保存记忆 ${value.id} @ ${renderScope(value.scope, agent)}`
144
+ // 0.35.2:带 hookCode 时把钩子的登记 / 审批结局回给模型 —— 否则它不知道
145
+ // 脚本到底挂没挂上、是不是还在等批准(未批准 = 不会运行)。
146
+ const hook = value.hook
147
+ if (hook === undefined) return head
148
+ const approvalText = {
149
+ approved: '已获批准,会按设定时机运行',
150
+ rejected: '用户拒绝批准,**不会运行**(改脚本或让用户批准后才生效)',
151
+ timeout: '等待批准超时,**不会运行**',
152
+ unavailable: '当前环境无法审批,**不会运行**',
153
+ unsupported: '当前 provider 不支持钩子,脚本未登记',
154
+ 'not-needed': '无需批准',
155
+ }
156
+ const state = hook.approval.startsWith('save-failed')
157
+ ? `登记失败:${hook.approval.slice('save-failed: '.length)}`
158
+ : approvalText[hook.approval] ?? hook.approval
159
+ return `${head}\n随附规则代码 ${hook.id !== '' ? `${hook.id} ` : ''}(${hook.phase}):${state}`
144
160
  })
145
161
 
146
162
  register(tools.memory_search, (value, _args, exec) => {
@@ -329,8 +329,13 @@ import { canonicalWorkspacePath, defaultScopeDescription, normalizeScopeInput, r
329
329
 
330
330
                             
331
331
 
332
-                
332
+                  
333
333
 
334
+
335
+                                      
336
+                                
337
+
338
+
334
339
                
335
340
 
336
341
 
@@ -2510,13 +2515,16 @@ export function memoryHooksTool(opts )
2510
2515
 
2511
2516
  // run:拿一段正文试跑,不写记忆。这是唯一能"先看效果再上线"的入口。
2512
2517
  const hook = findHook(service, args.id ?? '')
2513
- if (typeof service.runHooks !== 'function') {
2514
- throw new MemoryToolError('HOOKS_UNSUPPORTED', '当前 memory provider 不支持记忆钩子试跑')
2518
+ if (typeof service.runHookTrial !== 'function') {
2519
+ throw new MemoryToolError('HOOKS_UNSUPPORTED', '当前 memory provider 不支持记忆钩子试跑(请升级 @restregular/dsh-memory)')
2515
2520
  }
2516
2521
  const content = typeof args.content === 'string' && args.content.trim() !== ''
2517
2522
  ? args.content
2518
2523
  : throwErr(new MemoryToolError('HOOK_CONTENT_REQUIRED', 'run 需要 content:拿一段正文让脚本跑一次'))
2519
- const outcomes = service.runHooks(hook.phase, {
2524
+ // 0.35.2:按 id 精确试跑这一条,绕过审批门禁。老写法用 phase+scope/kind
2525
+ // 再过滤一遍,未批准的钩子会被门禁挡掉、表现为"脚本没有命中",与
2526
+ // 技能里"先 run 试跑再上线"的流程直接矛盾。
2527
+ const input = {
2520
2528
  memory: {
2521
2529
  scope: (args.scopes ?? hook.scopes)[0] ?? 'global',
2522
2530
  kind: (args.kinds ?? hook.kinds)[0] ?? 'rule',
@@ -2525,8 +2533,8 @@ export function memoryHooksTool(opts )
2525
2533
  importance: 0.8,
2526
2534
  },
2527
2535
  tool: 'memory_hooks',
2528
- })
2529
- const mine = outcomes.filter((outcome) => outcome.hook.id === hook.id)
2536
+ }
2537
+ const mine = service.runHookTrial(hook.id, input)
2530
2538
  const verdict = mine[0]
2531
2539
  const note = verdict === undefined
2532
2540
  ? '脚本没有命中这次输入(作用域/类型过滤把它排除了)。'
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@restregular/dsh-memory",
3
- "version": "0.35.1",
3
+ "version": "0.35.2",
4
4
  "description": "DeepSeek Harness 记忆系统(单包单入口):JSONL 存储 + 本地向量检索(BGE-M3)+ 五个模型工具 + 自动召回注入 + 管理面板。",
5
5
  "icon": "./icon.svg",
6
6
  "type": "module",