@restregular/dsh-memory 0.35.0 → 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,19 @@
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
+
12
+ ## 0.35.1 — 修复 0.35.0 实机验证发现的两个问题
13
+
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。
15
+ - **问题 2:hook 审批卡体验误导**。0.35.0 的 `mode='hook'` 审批复用普通"写入可见域外"的文案,既不说明"这是要在进程里运行的代码",还把代码 `\n` 压成一行、只截 180 字 —— 用户看不清就难以判断该不该批准(实测提交钩子后等到 5 分钟超时)。现在审批卡有专属分支:标题「提交了一段规则代码,需要你批准后才能运行」、按钮「批准这段代码」、代码用 `<pre>` 原样展示(保留换行、最高 260px 可滚动)、标出「规则代码 / 待批准 · 批准后运行」,不再显示误导性的 `custom:*` 作用域。
16
+ - 回归守卫:`source/memory-plugin/test/bundled-skills.test.ts` 锁住「必须用 inject 注册技能」「frontmatter 合法」「工具描述点名技能」「审批卡有 hookMode 专属文案与 `<pre>` 代码展示」四条。全套 634 tests / 633 pass / 1 skipped。
17
+
5
18
  ## 0.35.0 — 规则记忆可附带可执行代码:保存前校验 / 保存后观察 / 注入前解析
6
19
 
7
20
  - **规则从"写给模型看的话"变成"代码强制"**:`kind=rule` 的记忆此前只是常驻系统提示里的一段文字,模型可能记错、漏做、或压根不看。「记忆内容必须是『概括:正文』格式」这类**能写成检查**的规则,现在可以附带一段脚本,由插件在固定时机替你运行 —— 校验不通过就**直接拒绝这次保存**,不靠模型自觉。
package/lib/client.js CHANGED
@@ -706,6 +706,7 @@ window.__ModuleLoader__.load({
706
706
  '.mem-approval-bulk button:hover:not(:disabled){text-decoration:underline}',
707
707
  '.mem-approval-bulk button:disabled{color:var(--dsw-alias-label-secondary);opacity:.55;cursor:default;text-decoration:none}',
708
708
  '.mem-approval-summary{color:var(--dsw-alias-label-secondary);font-size:11.5px;line-height:1.5;word-break:break-word}',
709
+ '.mem-approval-code{margin:0;padding:8px 10px;max-height:260px;overflow:auto;white-space:pre-wrap;word-break:break-word;border-radius:8px;background:var(--dsw-alias-bg-layer-1);border:1px solid var(--dsw-alias-border-l1);color:var(--dsw-alias-label-primary);font-family:var(--ds-font-family-code,ui-monospace,monospace);font-size:11px;line-height:1.55}',
709
710
  '.mem-approval-check{display:inline-flex;align-items:center;justify-content:center;width:18px;height:18px;margin-top:1px;padding:0;border:none;background:transparent;flex:none;cursor:pointer}',
710
711
  '.mem-approval-check .box{display:flex;align-items:center;justify-content:center;width:16px;height:16px;border:1.5px solid color-mix(in srgb,var(--dsw-alias-label-secondary) 52%,var(--dsw-alias-border-l1));border-radius:5px;background:color-mix(in srgb,var(--dsw-alias-label-primary) 5%,transparent);color:var(--dsw-alias-label-primary-foreground);transition:background .12s ease,border-color .12s ease}',
711
712
  '.mem-approval-check.on .box{background:var(--dsw-alias-state-business-primary,#4176e6);border-color:var(--dsw-alias-state-business-primary,#4176e6);color:var(--dsw-alias-label-primary-foreground)}',
@@ -6847,8 +6848,14 @@ window.__ModuleLoader__.load({
6847
6848
  // 0.32.0:block 模式 = Agent 请求「屏蔽」某条记忆 / 某个作用域。它不改权限,
6848
6849
  // 只是让这些东西不再出现在检索、注入与目录里;可随时解除,所以文案要说清可逆。
6849
6850
  const blockMode = pending.mode === 'block'
6850
- const actionLabel = blockMode ? '屏蔽' : grantMode ? '访问' : action === 'write' ? '写入' : action === 'delete' ? '删除' : '读取'
6851
- const actionHint = blockMode
6851
+ // 0.35.0:hook 模式 = Agent 提交了一段要在 DSH 进程里运行的规则脚本。
6852
+ // 这比普通的"写入可见域外"危险得多:用户必须逐行看清代码再决定,绝不能套用
6853
+ // 那套"写入 / 读取"的文案(既误导,又把代码压成一行看不清)。
6854
+ const hookMode = pending.mode === 'hook'
6855
+ const actionLabel = hookMode ? '运行代码' : blockMode ? '屏蔽' : grantMode ? '访问' : action === 'write' ? '写入' : action === 'delete' ? '删除' : '读取'
6856
+ const actionHint = hookMode
6857
+ ? 'Agent 提交了一段脚本,批准后它会在 DSH 进程里运行(在沙箱内,无网络 / 文件访问)。请先逐行看清下面的代码和运行时机,再决定是否允许。代码改动后会再次征求你的同意。'
6858
+ : blockMode
6852
6859
  ? 'Agent 想把下列记忆从检索、注入与作用域目录里藏起来(不删除、可随时解除)。按作用域屏蔽、工作区级屏蔽,或目标是硬性规则时都需要你确认。'
6853
6860
  : grantMode
6854
6861
  ? 'Agent 申请访问可见域外的作用域。勾选要授予的权限(默认只读);授权仅在本会话有效,子 Agent 会继承。'
@@ -6938,7 +6945,9 @@ window.__ModuleLoader__.load({
6938
6945
 
6939
6946
  const allowLabel = busy === pending.id
6940
6947
  ? '处理中…'
6941
- : blockMode
6948
+ : hookMode
6949
+ ? '批准这段代码'
6950
+ : blockMode
6942
6951
  ? selectable && selectedCount !== allIds.length
6943
6952
  ? `屏蔽选中的 ${selectedCount} 项`
6944
6953
  : '确认屏蔽'
@@ -6955,7 +6964,7 @@ window.__ModuleLoader__.load({
6955
6964
  'data-approval-id': pending.id,
6956
6965
  onKeyDown: keydown,
6957
6966
  },
6958
- h('div', { className: 'mem-approval-card', role: 'dialog', 'aria-label': blockMode ? '记忆屏蔽审批' : grantMode ? '记忆访问授权审批' : `记忆${actionLabel}审批`, 'aria-busy': busy === pending.id },
6967
+ h('div', { className: 'mem-approval-card', role: 'dialog', 'aria-label': hookMode ? '规则代码运行审批' : blockMode ? '记忆屏蔽审批' : grantMode ? '记忆访问授权审批' : `记忆${actionLabel}审批`, 'aria-busy': busy === pending.id },
6959
6968
  h('div', { className: 'mem-approval-strip' },
6960
6969
  h('span', { className: 'mem-approval-dot' }),
6961
6970
  h('span', null, busy === pending.id ? '处理中…' : '等待审批'),
@@ -6975,7 +6984,9 @@ window.__ModuleLoader__.load({
6975
6984
  isCollapsed
6976
6985
  ? null
6977
6986
  : h('div', { className: 'mem-approval-body' },
6978
- h('div', { className: 'mem-approval-headline' }, blockMode
6987
+ h('div', { className: 'mem-approval-headline' }, hookMode
6988
+ ? `工具 ${pending.tool || 'memory'} 提交了一段规则代码,需要你批准后才能运行`
6989
+ : blockMode
6979
6990
  ? `工具 ${pending.tool || 'memory'} 请求屏蔽这些记忆 / 作用域`
6980
6991
  : grantMode
6981
6992
  ? `工具 ${pending.tool || 'memory'} 申请访问可见域外的作用域`
@@ -7053,20 +7064,28 @@ window.__ModuleLoader__.load({
7053
7064
  : grantMode
7054
7065
  ? (item.grantPermission === 'write' ? '可写' : '只读')
7055
7066
  : (String(item.id).length > 12 ? `${item.id.slice(0, 8)}…${item.id.slice(-4)}` : String(item.id))),
7056
- // 作用域显示名带类型前缀;title 里给出「显示名 → 真实键」。
7057
- h('span', { className: 'audit-pill mute', title: scopeTitle(item.scope, scopeLabel(item.scope)) }, scopeLabel(item.scope)),
7058
- grantMode
7067
+ // hook 模式的 scope 是 '*' 或逗号分隔的列表,不是记忆作用域键。
7068
+ hookMode
7069
+ ? null
7070
+ : h('span', { className: 'audit-pill mute', title: scopeTitle(item.scope, scopeLabel(item.scope)) }, scopeLabel(item.scope)),
7071
+ hookMode
7072
+ ? h('span', { className: 'audit-pill mute' }, '规则代码')
7073
+ : grantMode
7059
7074
  ? h('span', { className: 'audit-pill mute' }, item.grantPermission === 'write' ? '写入 / 删除' : '只读访问')
7060
7075
  : h('span', { className: 'audit-pill mute' }, item.kind ? kindMeta(item.kind).label : '未知'),
7061
7076
  blockMode
7062
7077
  ? h('span', { className: 'audit-pill warn' }, '屏蔽')
7063
7078
  : grantMode
7064
7079
  ? h('span', { className: 'audit-pill warn' }, '本会话授权')
7065
- : item.reason === 'kind'
7066
- ? h('span', { className: 'audit-pill warn' }, '类型受限')
7067
- : h('span', { className: 'audit-pill warn' }, '范围外'),
7080
+ : hookMode
7081
+ ? h('span', { className: 'audit-pill warn' }, '待批准 · 批准后运行')
7082
+ : item.reason === 'kind'
7083
+ ? h('span', { className: 'audit-pill warn' }, '类型受限')
7084
+ : h('span', { className: 'audit-pill warn' }, '范围外'),
7068
7085
  ),
7069
- h('div', { className: 'mem-approval-summary' }, blockMode
7086
+ hookMode
7087
+ ? h('pre', { className: 'mem-approval-code' }, String(item.content || ''))
7088
+ : h('div', { className: 'mem-approval-summary' }, blockMode
7070
7089
  ? '确认后它将不再出现在检索、注入与作用域目录里;数据不删除,随时可以解除。'
7071
7090
  : grantMode
7072
7091
  ? (item.grantPermission === 'write' ? '允许新增、修改与删除该作用域的记录' : '允许查询与读取该作用域的正文')
package/lib/index.js CHANGED
@@ -62,8 +62,14 @@ export function apply(ctx , config = {}) {
62
62
  part(ctx, 'panel', () => panelApply(ctx, config.panel ?? {}))
63
63
 
64
64
  // 4) 随包技能:记忆钩子的脚本 API 文档必须和代码同版本(0.35.0)。
65
- // 没有 skills 服务时静默跳过 —— 技能是增强,不是记忆功能的前置。
66
- part(ctx, 'skills', () => mountBundledSkills(ctx ))
65
+ // skills 服务由宿主核心提供,可能在本插件 apply 之后才提供 —— 用 ctx.inject
66
+ // 等它就绪再挂,不能在 apply 里 `ctx.get('skills')` 一次性取样(取到 undefined
67
+ // 就永久丢失,表现为「插件启用着但技能目录里没有」,重启或 toggle 才恢复)。
68
+ // 和 tools 一样放在独立 inject 回调里:技能是增强,缺它绝不能把整条 entry
69
+ // 拖成 PENDING(那会连 provider / 工具 / 面板一起起不来)。
70
+ ctx.inject(['skills'], (c ) => {
71
+ part(c, 'skills', () => mountBundledSkills(c ))
72
+ })
67
73
 
68
74
  // 5) 模型工具:同时需要工具注册表与本插件提供的 memory 服务。
69
75
  // 用 ctx.inject 而不是模块级 inject —— 缺服务时只是这四个工具不出现,
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
  *
package/lib/skills.js CHANGED
@@ -109,18 +109,25 @@ export function mountBundledSkills(ctx
109
109
 
110
110
 
111
111
  ) {
112
- // 0.35.0:`ctx.get('skills')` 在 apply 早期可能还是 undefined(服务由别的插件
113
- // provide)。此时**什么也不做** —— 记忆插件自己的工具/面板必须照常起来。
112
+ // 0.35.1 修复:调用方现在通过 ctx.inject(['skills'], scope => ...) 在服务**就绪后**
113
+ // 才进来,所以这里拿到的 ctx 就是已注入的 scope,skills 一定在。
114
+ // 保留 ctx.get 兜底是为了兼容仍在 apply 里直接调用它的老路径(测试 / 独立加载)。
114
115
  let skills
115
116
  try {
116
117
  skills = (ctx.skills ?? ctx.get?.('skills'))
117
118
  } catch {
118
119
  skills = undefined
119
120
  }
120
- if (skills === undefined || typeof skills.registerProvider !== 'function') return
121
+ if (skills === undefined || typeof skills.registerProvider !== 'function') {
122
+ ctx.logger?.warn?.('dsh-memory: skills 服务尚未就绪,随包技能未注册(记忆功能不受影响)')
123
+ return
124
+ }
121
125
 
122
126
  const names = skillNames()
123
- if (names.length === 0) return
127
+ if (names.length === 0) {
128
+ ctx.logger?.warn?.(`dsh-memory: 没找到随包技能目录 ${SKILLS_ROOT}`)
129
+ return
130
+ }
124
131
 
125
132
  const build = () => {
126
133
  const candidates = names.map(candidateFor)
@@ -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.0",
3
+ "version": "0.35.2",
4
4
  "description": "DeepSeek Harness 记忆系统(单包单入口):JSONL 存储 + 本地向量检索(BGE-M3)+ 五个模型工具 + 自动召回注入 + 管理面板。",
5
5
  "icon": "./icon.svg",
6
6
  "type": "module",