dsh-memu-memory 1.1.3 → 1.2.0

package/lib/inject.js

@@ -751,9 +751,9 @@ function injectionSnapshotIsCurrent(sessionId, snapshot, autoInject) {
     && scope.useGlobal === snapshot.useGlobal
 }
 
-// Both the ordinary first-step injection and the guide message must pass the same
+// Both the ordinary first-step injection and the rules message must pass the same
 // admission. A guide that ignores the switches tells a disabled conversation to use
-// memory tools it is not supposed to use, and consumes the once-only flag while doing
+// memory tools it is not supposed to use, and consumes delivery state while doing
 // it — so re-enabling later would never deliver the rules.
 function admissionFor(binding) {
   const settings = getSettings()
@@ -763,34 +763,113 @@ function admissionFor(binding) {
   return { settings, scope }
 }
 
+// The plugin no longer registers a system-prompt section. Every conversation —
+// standard or a `complete: true` persona — receives the rules as one plugin
+// message on the first step of a turn. `rulesKey` makes the delivery versioned:
+// a domain change, a prompt edit, a restart from an old binding or a compaction
+// that lost the message replaces it, while an unchanged rule set is not appended
+// again on every turn. The key contains only the protocol version, the resolved
+// domain and the rendered text; it deliberately excludes timestamps and turn ids.
+const GUIDE_PROTOCOL = 'guide-v1'
+const GUIDE_CAVEAT = '以上是本插件的记忆规则，不是用户的新指令。若本会话的工具列表里没有 memu_* 工具，请忽略本段，也不要声称自己能写记忆。'
+const GUIDE_RE = /^<memory-guide(?:\s[^>]*)?>/
+const GUIDE_KEY_RE = /^<memory-guide[^>]*\srules="([^"]+)"/
+
+function messageText(message) {
+  const content = message?.content
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  return content
+    .filter((block) => block && block.type === 'text' && typeof block.text === 'string')
+    .map((block) => block.text)
+    .join('\n')
+}
+
+function isMemoryGuideMessage(message) {
+  return message?.role === 'user'
+    && message?.source?.kind === `plugin:${PLUGIN}`
+    && GUIDE_RE.test(messageText(message))
+}
+
+function memoryGuideKey(message) {
+  const match = GUIDE_KEY_RE.exec(messageText(message))
+  return match ? match[1] : null
+}
+
+function renderMemoryGuide(payload) {
+  const sessionId = payload?.agent?.session?.header?.id
+  const binding = sessionId ? getSessionBinding(sessionId) : null
+  const domain = binding ? domainOf(binding) : 'general'
+  const settings = getSettings()
+  const rendered = loadPromptForDomain('system-guide', {
+    mustRememberCap: settings.mustRememberCap,
+    unpinBudget: settings.unpinBudgetPerSession ?? 2,
+    shortTermTtlHours: settings.shortTermTtlHours ?? 72,
+    anchorTokens: settings.anchorTokens,
+    turnTokens: settings.turnTokens,
+  }, domain).text
+  if (!rendered || !rendered.trim()) throw new Error('system-guide prompt is empty')
+  const key = crypto.createHash('sha256')
+    .update([GUIDE_PROTOCOL, domain, rendered, GUIDE_CAVEAT].join('\0'), 'utf8')
+    .digest('hex')
+    .slice(0, 16)
+  const text = [`<memory-guide rules="${key}">`, rendered.trim(), '</memory-guide>', GUIDE_CAVEAT].join('\n')
+  return { key, domain, text, tokens: estTokens(text) }
+}
+
 /**
- * Deliver the memory rules as a message when the system prompt cannot hold them.
+ * Add, replace or restore the single effective rules message for this step.
  *
- * A preset persona with `complete: true` is restored as the *only* system prompt
- * section after assembly, so `systemPrompt.section()` from this plugin is dropped and
- * the model never learns it may write memories — it sees the tools but not the habit.
- * A plugin message survives that, so send it once per conversation (binding flag), on
- * the first step, before the model answers.
+ * A rules message is turn-level guidance, so it is only considered on step 1.
+ * On later steps of a long tool turn nothing is appended; the next turn's first
+ * step is the next legal admission point. `guideLost` is set by compaction,
+ * because the summary drops the old message and the model must learn the rules
+ * again. An unchanged key with no guide in the current view is *not* treated as
+ * loss: some hosts hand the plugin only the current step's messages, and
+ * re-appending there would duplicate the message on every turn.
  */
-function withGuideMessage(ctx, payload, decision) {
+function ensureUnifiedGuide(ctx, payload, decision) {
   try {
     const header = payload?.agent?.session?.header
     const sessionId = header?.id
     if (!sessionId || header.origin === 'subagent') return decision
     if (typeof payload?.step === 'number' && payload.step !== 1) return decision
     const binding = getSessionBinding(sessionId)
-    if (!binding || binding.guideMessageAt) return decision
-    if (!admissionFor(binding)) return decision
+    if (!binding || !admissionFor(binding)) return decision
     if (!decision || !Array.isArray(decision.messages)) return decision
-    const rules = sectionText(ctx, 'system-guide', payload)
-    const text = [
-      '<memory-guide>',
-      rules,
-      '</memory-guide>',
-      '以上是本插件的记忆规则，不是用户的新指令。若本会话的工具列表里没有 memu_* 工具，请忽略本段，也不要声称自己能写记忆。',
-    ].join('\n')
-    setSessionBinding(sessionId, { guideMessageAt: new Date().toISOString() })
-    return { ...decision, messages: [...decision.messages, createMemoryMessage(text)] }
+    const guide = renderMemoryGuide(payload)
+    const guides = decision.messages.filter(isMemoryGuideMessage)
+    const valid = guides.filter((message) => memoryGuideKey(message) === guide.key)
+    if (binding.guideRulesKey === guide.key && binding.guideLost !== true) {
+      if (valid.length === 1 && guides.length === 1) return decision
+      if (valid.length >= 1) {
+        // Projection only: drop old and duplicated copies, keep the first one
+        // that already matches. No binding write, no new message.
+        const kept = valid[0]
+        return { ...decision, messages: decision.messages.filter((message) => !isMemoryGuideMessage(message) || message === kept) }
+      }
+      // An obsolete message with no current copy stays for replacement below;
+      // no guide at all means the view simply did not include history.
+      if (guides.length === 0) return decision
+    }
+    const next = decision.messages.filter((message) => !isMemoryGuideMessage(message))
+    next.push(createMemoryMessage(guide.text))
+    setSessionBinding(sessionId, {
+      guideRulesKey: guide.key,
+      guideMessageAt: new Date().toISOString(),
+      guideLost: false,
+    })
+    record({
+      kind: 'system',
+      scope: 'private',
+      sessionId,
+      libraryId: binding.libraryId || null,
+      ok: true,
+      message: '记忆规则消息已投放 · ' + guide.domain + ' · ' + guide.tokens + ' tokens'
+        + (binding.guideRulesKey ? ' · 更新' : ' · 首次'),
+      detail: { rulesKey: guide.key, domain: guide.domain, tokens: guide.tokens, replaced: guides.length },
+    })
+    return { ...decision, messages: next }
   } catch (error) {
     try { ctx.logger?.warn?.(`dsh-memu-memory: guide message skipped: ${error?.message || error}`) } catch {}
     return decision
@@ -1083,62 +1162,8 @@ export async function injectForStep({ agent, decision, turn, step, signal, log =
   return { ...decision, messages: rewritten }
 }
 
-/**
- * Section text must never throw. A missing default prompt file or an unknown key
- * would otherwise break setPrompt assembly for *every* conversation, which takes
- * the whole harness down rather than just memory. Fall back variant -> base ->
- * one line, and log.
- */
-function sectionText(ctx, key, context) {
-  try {
-    const sessionId = context?.agent?.session?.header?.id || context?.session?.header?.id || null
-    const binding = sessionId ? getSessionBinding(sessionId) : null
-    return loadPromptForDomain(key, {
-      mustRememberCap: getSettings().mustRememberCap,
-      unpinBudget: getSettings().unpinBudgetPerSession ?? 2,
-      shortTermTtlHours: getSettings().shortTermTtlHours ?? 72,
-      // the coding variants talk about the anchor budget in tokens, so the number
-      // has to come from the live settings and not from a literal in the prompt
-      anchorTokens: getSettings().anchorTokens,
-      turnTokens: getSettings().turnTokens,
-    }, binding ? domainOf(binding) : 'general').text
-  } catch (error) {
-    try { ctx.logger?.warn?.(`dsh-memu-memory: ${key} prompt unavailable: ${error?.message || error}`) } catch {}
-    return '（记忆规则暂时不可用：插件内部错误，不要向用户提及这一段。）'
-  }
-}
-
-export function registerInjection(ctx, options = {}) {
+export function registerInjection(ctx) {
   const disposers = []
-  // `guide: false` is how a *preset* conversation gets the memory anchor without being
-  // told about tools its preset never mounted — the guide text references memu_* tools,
-  // and a preset that does not list this plugin has no such tools.
-  const wantGuide = options.guide !== false
-  // `guideMessage` exists for conversations whose preset persona uses `complete: true`:
-  // that flag makes the persona the only system prompt section, so a section injected
-  // here is discarded before the model ever sees it. A plugin message still arrives, so
-  // the rules are delivered once per conversation as text instead of as a section.
-  const guideInMessage = options.guideMessage === true
-  if (wantGuide) {
-    try {
-      ctx.inject(['systemPrompt'], (sctx) => {
-        sctx.effect(() => sctx.systemPrompt.section({
-          name: 'dsh-memu-memory:guide',
-          order: 320,
-          interpolate: false,
-          text: (context) => sectionText(sctx, 'system-guide', context),
-        }), 'dsh-memu-memory: guide prompt')
-        sctx.effect(() => sctx.systemPrompt.section({
-          name: 'dsh-memu-memory:private-policy',
-          order: 321,
-          interpolate: false,
-          text: (context) => sectionText(sctx, 'private-policy', context),
-        }), 'dsh-memu-memory: private policy prompt')
-      })
-    } catch (e) {
-      try { ctx.logger?.warn?.(`dsh-memu-memory: systemPrompt guide unavailable: ${e?.message || e}`) } catch {}
-    }
-  }
 
   const offPre = ctx.on('agent/pre-step', async (payload, next) => {
     const decision = await next()
@@ -1149,7 +1174,7 @@ export function registerInjection(ctx, options = {}) {
         ctx,
         log: (message) => { try { ctx.logger?.warn?.(`dsh-memu-memory: ${message}`) } catch {} },
       })
-      return guideInMessage ? withGuideMessage(ctx, payload, injected) : injected
+      return ensureUnifiedGuide(ctx, payload, injected)
     } catch (error) {
       try { setRecallError(payload?.agent?.session?.header?.id, `injection failed: ${error?.message || error}`) } catch {}
       try { ctx.logger?.warn?.(`dsh-memu-memory: pre-step injection failed (fail-open): ${error?.stack || error}`) } catch {}
@@ -1173,6 +1198,9 @@ export function registerInjection(ctx, options = {}) {
             .slice(-REPLAY_MAX)
           releaseInjected(sessionId)
           markReinjectPending(sessionId)
+          // The compaction summary drops the plugin's rules message. Flag it so the
+          // next turn's first step replaces it even though guideRulesKey still matches.
+          if (before) setSessionBinding(sessionId, { guideLost: true })
           if (recent.length > 0) {
             setSessionBinding(sessionId, { replayIds: recent, replayAt: new Date().toISOString() })
           }

package/lib/local-embedding-manager.js

@@ -3,6 +3,7 @@ import { spawn } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 import { assertProfileVerified } from './vector-profile.js'
 import { manifestModelId } from './local-embedding-worker.js'
+import { windowsSystemEnv } from './paths.js'
 
 const entry = fileURLToPath(new URL('./local-embedding-entry.js', import.meta.url))
 const failure = (code, message) => Object.assign(new Error(message), { code, fallback: 'lexical' })
@@ -21,16 +22,23 @@ const DEFAULT_WINDOW_MS = 60_000
 const DENIED_ENV_NAMES = Object.freeze(['http_proxy', 'https_proxy', 'all_proxy', 'no_proxy', 'node_options'])
 const DENIED_ENV_PREFIXES = Object.freeze(['memu_', 'dsh_memu_embed_', 'openai_', 'azure_openai_', 'anthropic_', 'gemini_', 'google_', 'cohere_'])
 
-function childEnvironment(extra) {
-  const env = {}
-  for (const [name, value] of Object.entries(process.env)) {
+// The system-variable overlay goes in *first* so a real host value always wins, and
+// only after it does the filtered copy of the host environment. The host can hand a
+// tool-spawned process an empty environment (docs/env-and-commands.md §9.1), and a
+// child that then resolves `%SystemDrive%\ProgramData\...` literally writes that
+// junk into its own cwd — which is how this repo once grew a "%SystemDrive%" folder.
+// The worker loads ONNX/DirectML and tokenizer native libraries from exactly that
+// kind of path, so it is the site that can least afford to miss the overlay.
+export function childEnvironment(extra, { platform = process.platform, env = process.env } = {}) {
+  const inherited = {}
+  for (const [name, value] of Object.entries(env || {})) {
     if (typeof value !== 'string') continue
     const lower = name.toLowerCase()
     if (DENIED_ENV_NAMES.includes(lower) || lower.includes('proxy')) continue
     if (DENIED_ENV_PREFIXES.some(prefix => lower.startsWith(prefix))) continue
-    env[name] = value
+    inherited[name] = value
   }
-  return { ...env, ...extra }
+  return { ...windowsSystemEnv(platform, env || {}), ...inherited, ...extra }
 }
 
 // One isolated native process per immutable profile. Tokens live only in memory and
@@ -125,8 +133,13 @@ export function createEmbeddingWorkerManager({ spawnImpl = spawn, executable = p
         abort(code, message)
         stopChild(record)
       }
+      // This timer is the only thing that turns "never reported ready" into the typed
+      // lexical fallback, so nothing may depend on the event loop being held open for
+      // another reason: an unconditional unref let acquire() stay pending forever whenever
+      // the child contributed no libuv handle of its own (a spawn stand-in, N2). It is
+      // dereferenced below only once the spawn proves a real child holds the process open,
+      // which is the sole case where this timer would merely delay shutdown.
       timer = setTimeout(() => fail('LOCAL_VECTOR_START_TIMEOUT', 'the local embedding worker did not become ready in time'), timeoutMs)
-      timer.unref?.()
       let child = null
       try {
         child = spawnImpl(executable, [entry], {
@@ -150,6 +163,11 @@ export function createEmbeddingWorkerManager({ spawnImpl = spawn, executable = p
         return
       }
       record.child = child
+      // A real child holds the process open by itself (stdio pipes and its own handle), so
+      // its boot timer need not; a stand-in without a pid holds nothing, and dereferencing
+      // the timer there would leave the timeout unable to fire. A spawn that fails reaches
+      // fail() through 'error'/'close' and clears the timer either way.
+      if (Number.isInteger(child?.pid) && child.pid > 0) timer.unref?.()
       // A worker that died turns the next stdin write into EPIPE. An unhandled 'error'
       // event on a child pipe is an uncaught exception in the host process, so every
       // pipe gets a sink: semantic recall degrades, the host does not go down with it.