@a9i5k4/dsh-auto-memory 0.1.36 → 0.1.37

package/lib/client.js

@@ -495,6 +495,8 @@ window.__ModuleLoader__.load({
         '补丁 0.1.32:「记忆唤起」开关与设置页双向联动(导览与设置走同一 semantic-emit 接口);语义引擎分级引导(无引擎自动装 JS 档,发烧友可选 Python)。',
         '补丁 0.1.33:修复语义引擎下载 404(镜像 URL 重复前缀);transformers 推理库声明为可选依赖并随包分发。',
         '补丁 0.1.34:修复推理库检测——pnpm 把 transformers 提升到 profile 根 node_modules,检测补该路径,新用户装完即用,无需手动操作。',
+        '补丁 0.1.37:修复「弹窗关不掉」(#13,感谢 @eclgo 报告)——暂离回归面板只在 away→active 翻转时弹一次;0.1.36 起回归检测全局化后,回归前(尚未发消息)面板会被每 30 秒强制重开,现已根治。',
+        '补丁 0.1.37:修复语义引擎「推理库缺失」误报 (#14,感谢 @moonltppt 报告)——推理库探测改用 Node 真实解析,覆盖 npm/pnpm(hoisted/isolated)全部安装布局;并新增「打开即自动检测」:检测不到自动深度扫描(~/.dsh/profiles 全家 + pnpm 虚拟存储),命中即热接入(无需重启),仍缺才推荐安装/一键下载,推荐卡 24 小时免打扰。',
       ], en: [
         '★ MAJOR: Brand-new Welcome Tour — after first launch or upgrade, every feature is introduced step by step with per-feature switches right in the tour (association / snapshot / greeting / night unattended / reflection / summaries / external memory / skill promotion…); engine detection, download, self-test and live external-source scanning are all inline.',
         '★ New brand visuals: an Office/Fluent-style liquid-glass app icon family — each step gets its own colored glass squircle icon (cyan inject / amber greeting / green calendar / violet engine / sky radar / coral finish) with dedicated looping motion (bell sway, page flip, linked rings, prism spin, radar sweep, rising spark); the signature three-slab frosted-glass logo stays on the Core step.',
@@ -508,6 +510,8 @@ window.__ModuleLoader__.load({
         'Patch 0.1.32: the "Memory recall" switch now syncs bidirectionally with Settings (tour and settings share the semantic-emit endpoint); tiered engine onboarding (auto-install JS tier, Python optional for enthusiasts).',
         'Patch 0.1.33: fixed semantic-engine download 404 (duplicate prefix in mirror URL); transformers inference lib declared as an optional dependency and shipped with the package.',
         'Patch 0.1.34: fixed inference-lib detection — pnpm hoists transformers to the profile-root node_modules; detection now covers that path, so fresh installs work out of the box.',
+        'Patch 0.1.37: fixed the "popup cannot be closed" loop (#13, thanks @eclgo) — the welcome-back panel now opens only on the away→active transition; since 0.1.36 globalised away detection, the panel was force-reopened every 30s until the first message after returning. Root-caused and fixed.',
+        'Patch 0.1.37: fixed the false "inference runtime missing" state (#14, thanks @moonltppt) — runtime detection now uses real Node resolution, covering npm/pnpm (hoisted/isolated) layouts; plus a new check-on-open flow: when not detected, a deep scan (~/.dsh/profiles + pnpm virtual store) runs automatically and hot-wires hits with no restart; only if still missing does it recommend installing / one-click download, with a 24h snooze.',
       ] },
       '0.1.29': { zh: [
         '修复:工作区总览一直显示「未发现带记忆的工作区」——DSH 新版会话持久化改为 session.jsonl.zstd 压缩帧,旧逻辑只认 .jsonl 扫描不到任何会话;现已用 zstd 解压读取首行提取 cwd,并让空的 summary 缓存短时失效,避免空结果被永久固化。',
@@ -654,6 +658,7 @@ window.__ModuleLoader__.load({
       if (d.kind === 'notice') return d.notice && d.notice.level === 'urgent' ? 80 : 70
       if (d.kind === 'summary') return 60
       if (d.kind === 'welcomeBack') return 50
+      if (d.kind === 'semSetup') return 45
       return 10
     }
     function dialogKey(d) {
@@ -721,6 +726,8 @@ window.__ModuleLoader__.load({
       greet: '/api/dsh-auto-memory/greet',
       notices: '/api/dsh-auto-memory/notices',
       models: '/api/dsh-auto-memory/models',
+      semanticDeepDetect: '/api/dsh-auto-memory/semantic-deep-detect',
+      semanticDownload: '/api/dsh-auto-memory/semantic-download',
     }
     function query(params) {
       var search = new URLSearchParams()
@@ -2961,6 +2968,50 @@ window.__ModuleLoader__.load({
             h('div', { style: { display: 'flex', justifyContent: 'flex-end', marginTop: '6px' } },
               h('button', { 'data-dam-btn': '', style: close, onClick: closeDialog }, t('gotIt')))))
       }
+      if (dialogState.kind === 'semSetup') {
+        // 打开即自动检测引导卡(0.1.37,#14 后续):快检+深扫仍未就绪时推荐补装/一键下载;
+        // 深扫命中已热接入则报喜(即时生效)。关闭 = 24h 免打扰,不反复打扰。
+        var sd = dialogState.result || {}
+        var sdZh = locale === 'zh'
+        var sdBody = { fontSize: 'calc(12px * var(--dam-scale))', lineHeight: 1.6, opacity: .92, whiteSpace: 'pre-wrap', marginTop: '4px' }
+        var sdRows = []
+        var sdActions = []
+        var sdCmd = 'pnpm approve-builds\npnpm add @huggingface/transformers\n# 然后重启 dsh web'
+        var sdSnooze = function () {
+          try { localStorage.setItem('dsh-auto-memory.semDetectSnoozeUntil', String(Date.now() + 24 * 3600 * 1000)) } catch (eSn) {}
+          closeDialog()
+        }
+        if (sd.deep && sd.deep.integrated) {
+          sdRows.push(h('div', { style: sdBody }, sdZh
+            ? '检测到你已安装推理库 @huggingface/transformers（常规路径此前未识别，深度扫描已命中并自动接入）。语义检索 C2 现在即可用，无需重启。'
+            : 'Your installed @huggingface/transformers was found by the deep scan and hot-wired automatically. The C2 semantic tier is ready now — no restart needed.'))
+        } else {
+          if (sd.recommendation === 'install-peer' || sd.recommendation === 'setup-both') {
+            sdRows.push(h('div', { style: sdBody }, sdZh
+              ? (sd.recommendation === 'setup-both' ? '语义模型与推理库都未检测到。推理库请在安装 dsh-auto-memory 的同一目录（dsh profile）执行：' : '语义模型已下载，但推理库缺失（已含深度扫描）。请在安装 dsh-auto-memory 的同一目录（dsh profile）执行：')
+              : (sd.recommendation === 'setup-both' ? 'Neither the model assets nor the inference runtime were found. For the runtime, run in the directory where dsh-auto-memory is installed (the dsh profile):' : 'Model assets found, but the inference runtime is missing (deep scan included). Run in the directory where dsh-auto-memory is installed (the dsh profile):')))
+            sdActions.push(h('button', { 'data-dam-btn': '', style: close, onClick: function () {
+              try { if (navigator.clipboard && navigator.clipboard.writeText) navigator.clipboard.writeText(sdCmd) } catch (eCp) {}
+            } }, sdZh ? '复制命令' : 'Copy commands'))
+          }
+          if (sd.recommendation === 'download-model' || sd.recommendation === 'setup-both') {
+            sdRows.push(h('div', { style: sdBody }, sdZh
+              ? '语义模型（内置 JS 档，约 135MB，一次即可）可一键后台下载，下载完成后语义检索自动启用：'
+              : 'The built-in JS semantic model (~135MB, one-time) can be downloaded in the background; the semantic tier enables itself once done:'))
+            sdActions.push(h('button', { 'data-dam-btn': '', 'data-primary': 'true', style: close, onClick: function () {
+              apiPost(API.semanticDownload, { action: 'start', mirror: 'auto' }).catch(function () {})
+              closeDialog()
+            } }, sdZh ? '立即下载' : 'Download now'))
+          }
+        }
+        return h('div', { style: overlay },
+          h('div', { style: box },
+            h('div', { style: head }, sdZh ? '自动记忆引擎检测' : 'Memory engine check'),
+            sdRows,
+            h('div', { style: { display: 'flex', gap: '8px', justifyContent: 'flex-end', marginTop: '6px' } },
+              sdActions,
+              h('button', { 'data-dam-btn': '', style: close, onClick: (sd.deep && sd.deep.integrated) ? closeDialog : sdSnooze }, t('gotIt')))))
+      }
       var versions = dialogState.versions || []
       var lastV = versions.length ? versions[versions.length - 1].version : ''
       return h('div', { style: overlay },
@@ -3505,8 +3556,10 @@ window.__ModuleLoader__.load({
       })
       // 语言切换时通知所有订阅者重渲染
       onLocale(function () { emit() })
-      // 暂离回来自动弹开记忆窗口:host 判定暂离(阈值可配 awayMinutes),页面加载/切回标签页/轮询发现回归时自动打开
-      // 回归检测:host away 状态从 true → false(暂离结束)时打开并欢迎
+      // 暂离回来自动弹开记忆窗口:host 判定暂离(阈值可配 awayMinutes),轮询发现回归(true→false)时自动打开。
+      // v0.1.37 修复(#13):本函数不得做「away 且面板关着就再弹开」——≤0.1.35 host 侧 away 无写入点恒 false
+      // 掩盖了旧行,0.1.36 全局 away 激活后它变成 30s 重开死循环:用户回到机器但还没发消息时 host 恒判 away,
+      // 关掉即被重弹(=「弹窗关不掉」)。契约以设置页文案为准:回归(away true→false)才弹,away 挂着绝不强弹。
       var prevAwayState = null
       function autoOpenOnReturn() {
         try {
@@ -3517,11 +3570,8 @@ window.__ModuleLoader__.load({
             var pend = lastPendingSummary
             if (pend) { openDialog({ kind: 'summary', summary: pend }); lastPendingSummary = null }
             else if (!document.hidden) openDialog({ kind: 'welcomeBack' })
-            prevAwayState = hostAway
-            return
           }
           prevAwayState = hostAwayReady ? hostAway : prevAwayState
-          if (isAway() && !controller.isOpen()) controller.open()
         } catch (e) {}
       }
       autoOpenOnReturn()
@@ -3595,6 +3645,23 @@ window.__ModuleLoader__.load({
       checkNotices()
       var noticesTimer = setInterval(checkNotices, 3600 * 1000)
 
+      // 打开即自动检测语义引擎(0.1.37,#14 后续):每次打开页面一次「快检 → 失败自动深扫
+      // (~/.dsh/profiles 全家 + pnpm 虚拟存储) → 仍缺才推荐」。深扫命中即热接入(即时生效);
+      // 推荐卡关闭 = 24h 免打扰。延迟 12s 错开开屏的向导/changelog 弹窗(优先级本身也压它一头)。
+      setTimeout(function () {
+        apiGet(API.semanticDeepDetect).then(function (d) {
+          try {
+            if (!d || d.ready) return
+            if (!(d.deep && d.deep.integrated)) {
+              var sdUntil = 0
+              try { sdUntil = Number(localStorage.getItem('dsh-auto-memory.semDetectSnoozeUntil') || 0) } catch (eSn) {}
+              if (Date.now() < sdUntil) return
+            }
+            openDialog({ kind: 'semSetup', result: d })
+          } catch (eSD) {}
+        }).catch(function () {})
+      }, 12000)
+
       // 时间检测轮询(30s):拉 host 的暂离状态/待展示总结,检测暂离回归并自动弹窗
       var lastPendingSummary = null
       var awayPollTimer = null

package/lib/index.js

@@ -32,7 +32,7 @@ import { createContextHost } from './context-host.js'
 import { createSuccessEvidencePre } from './context-bridge.js'
 import { createIndexSyncHostPre } from './m7-index-sync-host.js'
 import { createActivationHost } from './activation-host.js'
-import { createJsSemanticEnginePre, createSemanticDownloaderPre, fuseD6Pre, E5_SMALL_Q8_MANIFEST_V1 } from './semantic-js.js'
+import { createJsSemanticEnginePre, createSemanticDownloaderPre, fuseD6Pre, probeJsSemanticAssets, deepScanPeerTransformers, E5_SMALL_Q8_MANIFEST_V1 } from './semantic-js.js'
 import { loadAndVerifyPolicy, decideActivationV2, lexicalContainment } from './semantic-decide.js'
 import { createPythonSidecarClientPre, defaultWorkerScriptPathPre } from './python-sidecar-client.js'
 import { createEpisodicStorePre } from './episodic-store.js'
@@ -93,6 +93,7 @@ export const API = {
   notices: '/api/dsh-auto-memory/notices',
   'activation-inbox': '/api/dsh-auto-memory/activation-inbox',
   'semantic-status': '/api/dsh-auto-memory/semantic-status',
+  'semantic-deep-detect': '/api/dsh-auto-memory/semantic-deep-detect',
   'semantic-download': '/api/dsh-auto-memory/semantic-download',
   'semantic-emit': '/api/dsh-auto-memory/semantic-emit',
   'shadow-recent': '/api/dsh-auto-memory/shadow-recent',
@@ -4352,28 +4353,45 @@ export function apply(ctx, config) {
     const pluginDir = path.dirname(fileURLToPath(import.meta.url))
     engine._jsSemantic = createJsSemanticEnginePre({ pluginDir })
     engine._jsDownload = createSemanticDownloaderPre({ modelsRoot: path.join(pluginDir, 'models') })
-    // 资产探测(semantic-status / 档位解析 / 引导卡共用):发行包 models/ 优先,其次开发树
-    engine.semanticAssetProbe = async () => {
-      const fsMod = await import('node:fs')
-      const cands = [
-        path.join(pluginDir, 'models', 'multilingual-e5-small', 'onnx', 'model_quantized.onnx'),
-        path.join(pluginDir, '..', 'artifacts', 'm7-live-pre', 'js-semantic-trial', 'models', 'multilingual-e5-small', 'onnx', 'model_quantized.onnx'),
-      ]
-      const modelOnnx = cands.find((c) => fsMod.existsSync(c)) || cands[0]
-      const peerCands = [
-        path.join(pluginDir, 'node_modules', '@huggingface', 'transformers'),
-        // pnpm 默认把 peer/optional 依赖提升到 profile 根 node_modules(pluginDir 上两级)
-        path.join(pluginDir, '..', '..', '..', 'node_modules', '@huggingface', 'transformers'),
-        path.join(pluginDir, '..', 'artifacts', 'm7-live-pre', 'js-semantic-trial', 'node_modules', '@huggingface', 'transformers'),
-      ]
-      const peerDir = peerCands.find((c) => fsMod.existsSync(c)) || peerCands[0]
-      const assetPresent = fsMod.existsSync(modelOnnx)
+    // 资产探测(semantic-status / 档位解析 / 引导卡共用):共享实现见 semantic-js-pre 的
+    // probeJsSemanticAssets —— peer 探测与引擎加载走同一套 Node 解析(2026-09-02 issue 修正)。
+    // _peerExtraDirs = 深度扫描热接入位(semanticDeepDetect 命中后 probe/加载/档位即时生效)。
+    engine._peerExtraDirs = []
+    engine.semanticAssetProbe = async () => probeJsSemanticAssets(pluginDir, engine._peerExtraDirs)
+    // 打开即自动检测(0.1.37,#14 后续):快检 → 模型在场但推理库缺失时深度扫描
+    // (~/.dsh/profiles/* 全家 + pnpm 虚拟存储) → 命中即热接入(probe/加载双注入,无需重启),
+    // 并给出 recommendation 供引导卡分流(none/setup-both/download-model/install-peer)。
+    engine.semanticDeepDetect = async () => {
+      const quick = await engine.semanticAssetProbe()
+      const deep = { scanned: false, foundDirs: [], integrated: false }
+      if (!quick.ready && quick.assetPresent) {
+        deep.scanned = true
+        try {
+          const osMod = await import('node:os')
+          const profilesRoot = path.join(osMod.homedir(), '.dsh', 'profiles')
+          const found = deepScanPeerTransformers([path.join(pluginDir, '..'), profilesRoot])
+          deep.foundDirs = found
+          for (const d of found) {
+            deep.integrated = true
+            if (!engine._peerExtraDirs.includes(d)) engine._peerExtraDirs.push(d)
+            try { if (engine._jsSemantic && engine._jsSemantic.addPeerDirCandidates) engine._jsSemantic.addPeerDirCandidates([d]) } catch (_) {}
+          }
+        } catch (_) { /* 扫描失败按未命中处理 */ }
+      }
+      const after = await engine.semanticAssetProbe()
+      const recommendation = after.ready ? 'none'
+        : (!after.assetPresent && !after.peerPresent) ? 'setup-both'
+        : (!after.peerPresent) ? 'install-peer'
+        : 'download-model'
       return {
-        assetPresent,
-        peerPresent: fsMod.existsSync(peerDir),
-        ready: Boolean(assetPresent && fsMod.existsSync(peerDir)),
-        assetBytes: assetPresent ? fsMod.statSync(modelOnnx).size : 0,
-        assetPath: modelOnnx,
+        assetPresent: after.assetPresent,
+        peerPresent: after.peerPresent,
+        ready: after.ready,
+        assetBytes: after.assetBytes,
+        assetPath: after.assetPath,
+        resolvedTier: await engine.resolveSemanticTier(),
+        deep,
+        recommendation,
       }
     }
     // 档位解析:lexical→C1 强制保底;其余(auto/js/python)在资产就绪时启用 C2 臂
@@ -4552,12 +4570,13 @@ export function apply(ctx, config) {
       // 审查修复轮3:有效性判断必须是严格 session 身份 —— !!agent.session 会放行无身份对象
       const hasAgent = !!(agent && engine.hasReliableSessionIdentity(agent))
       if (hasAgent) {
+        // 套娃防护(问题②):本插件 spawn 的子代理事件零处理——其 turn 结束不得再触发沉淀/路由,
+        // 也不得刷新活动戳(v0.1.37 修正:后台沉淀/定时总结若刷新活动戳,会把真暂离误翻成「回归」)
+        try { if (engine._ownSubagents && engine._ownSubagents.has(agent)) return } catch (e) {}
         // 最后活动时间写入该 agent 自己的 runtime(不再落到 currentRuntime()/default)
         try { engine.runtimeFor(agent).lastActiveAt = Date.now() } catch (e) {}
         // 全局活动戳同步更新(暂离检测统揽全局,见 tickTime)
         engine._globalLastActiveAt = Date.now()
-        // 套娃防护(问题②):本插件 spawn 的子代理事件零处理——其 turn 结束不得再触发沉淀/路由
-        try { if (engine._ownSubagents && engine._ownSubagents.has(agent)) return } catch (e) {}
         try { engine.ingestAgentLifecycle(agent, 'agent/turn-stopping', { turn: payload && payload.turn, payload: { turn: payload && payload.turn } }) } catch (e) {}
       }
       diag('turn-stopping fired: turn=' + JSON.stringify(payload && payload.turn) + ' hasAgent=' + hasAgent + ' payloadKeys=' + (payload ? Object.keys(payload).join(',') : 'null'))
@@ -4946,6 +4965,15 @@ export function apply(ctx, config) {
         } catch (e) { return writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
       },
     },
+    {
+      kind: 'exact',
+      path: API['semantic-deep-detect'],
+      handler: async (req, res) => {
+        // 打开即自动检测(0.1.37;GET 只读;loopback):快检+失败自动深扫+命中热接入+引导分流。
+        if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
+        try { return writeJson(res, 200, await engine.semanticDeepDetect()) } catch (e) { return writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
+      },
+    },
     {
       kind: 'exact',
       path: API['semantic-download'],

package/lib/semantic-js.js

@@ -13,8 +13,9 @@
  * 「要不要打断」仍属两车道策略(Python sidecar 在场时)。全部函数对非法输入 fail closed。
  */
 import { createHash } from 'node:crypto'
-import { existsSync, readFileSync, mkdirSync, renameSync, unlinkSync, writeFileSync, rmSync } from 'node:fs'
+import { existsSync, readFileSync, mkdirSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync, rmSync } from 'node:fs'
 import { fileURLToPath, pathToFileURL } from 'node:url'
+import { createRequire } from 'node:module'
 import path from 'node:path'
 
 export const JS_SEMANTIC_ENGINE_VERSION = 'js_semantic_engine_v1'
@@ -74,14 +75,106 @@ function defaultModelsDirCandidates(pluginDir) {
 }
 
 function defaultPeerDirCandidates(pluginDir) {
+  // pluginDir = <pkg>/lib(2026-09-02 issue 复核修正:此前上溯层级错位 → peerPresent 恒 false)。
+  // 静态候选仅作兜底,主路径是 resolvePeerTransformersDir 的真实解析:
+  //   1) lib/node_modules —— issue 临时 junction 绕过位(向后兼容)
+  //   2) <pkg>/node_modules —— 包内邻接位(lib 上 1 级再进 node_modules)
+  //   3) lib 上 3 级直拼 @huggingface —— 标准布局即 <root>/node_modules(pnpm hoisted/npm 提升),
+  //      pnpm isolated 下即虚拟存储包内位 .pnpm/<hash>/node_modules
+  //   4) 开发树 artifacts
   return [
     path.join(pluginDir, 'node_modules', '@huggingface', 'transformers'),
-    // pnpm 默认把 peer/optional 依赖提升到 profile 根 node_modules(pluginDir 上两级)
-    path.join(pluginDir, '..', '..', '..', 'node_modules', '@huggingface', 'transformers'),
+    path.join(pluginDir, '..', 'node_modules', '@huggingface', 'transformers'),
+    path.join(pluginDir, '..', '..', '..', '@huggingface', 'transformers'),
     path.join(pluginDir, '..', 'artifacts', 'm7-live-pre', 'js-semantic-trial', 'node_modules', '@huggingface', 'transformers'),
   ]
 }
 
+/**
+ * peer 探测(2026-09-02 issue 修正):真实解析优先 —— createRequire 从 lib/ 起走 Node 标准
+ * 解析,天然覆盖 npm/pnpm(hoisted/isolated 虚拟存储)/junction 全部布局,且不执行模块本体
+ * (require.resolve 只解析不加载);静态候选仅作 exports 损坏等极端情形的兜底;
+ * extraDirs = 深度扫描(semanticDeepDetect)热接入的额外目录,最后兜底检查。
+ * 返回命中的包目录,''=未找到。
+ */
+export function resolvePeerTransformersDir(pluginDir, extraDirs) {
+  try {
+    const req = createRequire(path.join(pluginDir, 'noop.js'))
+    const entry = req.resolve('@huggingface/transformers')
+    // entry 是包 main 文件(可能在任意子目录,如 dist/transformers.node.cjs):
+    // 从 entry 向上走到 package.json 所在层 = 包目录
+    if (entry && existsSync(entry)) {
+      let dir = path.dirname(entry)
+      while (dir && !existsSync(path.join(dir, 'package.json'))) {
+        const up = path.dirname(dir)
+        if (up === dir) { dir = ''; break }
+        dir = up
+      }
+      if (dir) return dir
+    }
+  } catch (_) { /* 静态候选兜底 */ }
+  const hit = defaultPeerDirCandidates(pluginDir).find((c) => existsSync(c))
+  if (hit) return hit
+  for (const d of Array.isArray(extraDirs) ? extraDirs : []) {
+    if (typeof d === 'string' && d && existsSync(d)) return d
+  }
+  return ''
+}
+
+/**
+ * 深度扫描(0.1.37「打开即自动检测」;issue #14 后续):零依赖手扫常见安装根。
+ * 每个 root 探两层:root 自身的 node_modules(直传 profile 根/包根时命中)+ 一级子目录
+ * (直传 ~/.dsh/profiles 时枚举各 profile);每个落位再探 node_modules/@huggingface/
+ * transformers、pnpm 虚拟存储 .pnpm/node_modules/... 与 .pnpm/@huggingface+transformers@版本
+ * /node_modules/...(isolated 模式包体落位)。返回存在的包目录列表(去重,保持扫描序)。
+ */
+export function deepScanPeerTransformers(roots) {
+  const out = []
+  const seen = new Set()
+  const push = (p) => { if (p && !seen.has(p) && existsSync(p)) { seen.add(p); out.push(p) } }
+  const probeDir = (base) => {
+    if (!base || typeof base !== 'string') return
+    push(path.join(base, 'node_modules', '@huggingface', 'transformers'))
+    push(path.join(base, 'node_modules', '.pnpm', 'node_modules', '@huggingface', 'transformers'))
+    const pnpmDir = path.join(base, 'node_modules', '.pnpm')
+    let entries = []
+    try { entries = readdirSync(pnpmDir) } catch (_) { /* base 无 .pnpm 虚拟存储 */ }
+    for (const e of entries) {
+      if (/^@huggingface\+transformers@/.test(e)) push(path.join(pnpmDir, e, 'node_modules', '@huggingface', 'transformers'))
+    }
+  }
+  for (const root of Array.isArray(roots) ? roots : []) {
+    if (!root || typeof root !== 'string') continue
+    probeDir(root)
+    let children = []
+    try { children = readdirSync(root) } catch (_) { /* root 不可枚举 */ }
+    for (const c of children.slice(0, 64)) probeDir(path.join(root, c))
+  }
+  return out
+}
+
+/**
+ * semanticAssetProbe 共享实现(index.js 的 status API / 档位解析 / 引导卡同源):
+ * 模型资产=发行包 lib/models 优先,其次开发树;peer=resolvePeerTransformersDir。
+ * extraDirs 透传给 peer 探测(深度扫描热接入位)。返回形状与 v0.1.36 完全一致。
+ */
+export function probeJsSemanticAssets(pluginDir, extraDirs) {
+  const modelCands = [
+    path.join(pluginDir, 'models', E5_MODELS_SUBDIR, 'onnx', 'model_quantized.onnx'),
+    path.join(pluginDir, '..', 'artifacts', 'm7-live-pre', 'js-semantic-trial', 'models', E5_MODELS_SUBDIR, 'onnx', 'model_quantized.onnx'),
+  ]
+  const modelOnnx = modelCands.find((c) => existsSync(c)) || modelCands[0]
+  const assetPresent = existsSync(modelOnnx)
+  const peerDir = resolvePeerTransformersDir(pluginDir, extraDirs)
+  return {
+    assetPresent,
+    peerPresent: Boolean(peerDir),
+    ready: Boolean(assetPresent && peerDir),
+    assetBytes: assetPresent ? statSync(modelOnnx).size : 0,
+    assetPath: modelOnnx,
+  }
+}
+
 async function importPeerTransformers(peerDirs) {
   try {
     return await import('@huggingface/transformers') // 发行包:peer 邻接安装
@@ -213,6 +306,12 @@ export function createJsSemanticEnginePre(opts = {}) {
         embedding: !!rebuilding,
       }
     },
+    /** 深度扫描热接入(0.1.37):把扫描发现的额外 peer 目录并入加载候选(去重,立即生效)。 */
+    addPeerDirCandidates(dirs) {
+      for (const d of Array.isArray(dirs) ? dirs : []) {
+        if (typeof d === 'string' && d && !peerDirCands.includes(d)) peerDirCands.push(d)
+      }
+    },
     /**
      * 对语料做稠密排名。返回 {miv, scores:Map(memoryId→cosine)};失败返回 null(调用方回退词法)。
      */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@a9i5k4/dsh-auto-memory",
   "description": "主动联想记忆插件:记忆不靠模型调用,自己被唤回——Host 观察情境,NLP+向量化双轨检索,固定边界注入不破坏前缀缓存。三层记忆自动沉淀、欢迎向导、唤起回顾、无人值守、AI 问候与反思、日历、跨工具记忆继承。Proactive associative memory for DSH: zero-call recall, three-layer auto-consolidation, welcome tour, unattended mode.",
-  "version": "0.1.36",
+  "version": "0.1.37",
   "type": "module",
   "main": "lib/index.js",
   "exports": {