dsh-memu-memory 1.1.0 → 1.1.2

package/lib/client.js

@@ -343,8 +343,9 @@ window.__ModuleLoader__.load({
       browse: '浏览',
       export: '导出 JSON',
       importJson: '导入 JSON',
-      importHint: '选择导出的 JSON 或图片 ZIP。按正文去重；已归档与失效条目跳过；session 私有范围保持限制，不自动改为共享。',
+      importHint: '选择导出的 JSON 或图片 ZIP。按正文去重；已归档与失效条目跳过；老版本里限定在某段对话的条目会按「共享」导入，并在报告里单独列出（要收窄请补 context 字段）。',
       importDone: '导入完成（新增 / 跳过）',
+      importAdjusted: '已按新语义调整',
       importEngineWarning: '记忆已写入索引，但引擎提交失败，语义检索暂时看不到它们',
       newMemory: '新建记忆',
       memoryTitle: '标题（可留空）',
@@ -385,7 +386,6 @@ window.__ModuleLoader__.load({
       ownerAboutUser: '关于他',
       ownerAboutProject: '关于项目',
       visShared: '共享',
-      visSession: '本会话',
       visSecret: '秘密',
       sourceUserSaid: '对方的话',
       sourceInferred: '我推断',
@@ -501,6 +501,7 @@ window.__ModuleLoader__.load({
       memoryPromptBody: '记忆保存在 ~/.dsh/dsh-memu-memory/，删除对话不会删除记忆。',
       chooseLibrary: '选择已有记忆库',
       createLibrary: '新建记忆库',
+      folderLibrary: '用文件夹自带的记忆库',
       memOffTitle: '不用记忆',
       memOffDesc: '这段对话什么都不记。已有记忆仍留在磁盘上，之后可以在侧边栏改。',
       memPrivateTitle: '只用私有记忆',
@@ -755,8 +756,9 @@ window.__ModuleLoader__.load({
       browse: 'Browse',
       export: 'Export JSON',
       importJson: 'Import JSON',
-      importHint: 'Import exported JSON or an image ZIP. Duplicate and inactive entries are skipped; session-scoped entries remain restricted and are never widened to shared.',
+      importHint: 'Import exported JSON or an image ZIP. Duplicate and inactive entries are skipped; entries an older export scoped to one conversation are imported as shared and listed separately in the report (add context fields to narrow them).',
       importDone: 'Imported (added / skipped)',
+      importAdjusted: 'adjusted to the current semantics',
       importEngineWarning: 'Memories are in the index, but the engine commit failed, so semantic recall cannot see them yet',
       newMemory: 'New memory',
       memoryTitle: 'Title (optional)',
@@ -796,7 +798,6 @@ window.__ModuleLoader__.load({
       ownerAboutUser: 'about them',
       ownerAboutProject: 'about project',
       visShared: 'shared',
-      visSession: 'session',
       visSecret: 'secret',
       sourceUserSaid: 'their words',
       sourceInferred: 'inferred',
@@ -912,6 +913,7 @@ window.__ModuleLoader__.load({
       memoryPromptBody: 'Memory is stored in ~/.dsh/dsh-memu-memory/. Deleting the conversation does not delete memory.',
       chooseLibrary: 'Choose an existing library',
       createLibrary: 'Create a new library',
+      folderLibrary: "Use this folder's library",
       memOffTitle: 'No memory',
       memOffDesc: 'This conversation keeps nothing. Existing memories stay on disk and the setting can be changed later in the sidebar.',
       memPrivateTitle: 'Private memory only',
@@ -1526,7 +1528,7 @@ window.__ModuleLoader__.load({
     const STATUS_LABELS = { active: 'stActive', archived: 'stArchived', suppressed: 'stSuppressed', superseded: 'stSuperseded', pending_review: 'stPendingReview', expired: 'stExpired' }
     const DISCLOSURE_LABELS = { can_tell: 'discCanTell', only_if_asked: 'discOnlyIfAsked', never_say: 'discNeverSay' }
     const OWNER_LABELS = { me: 'ownerMe', us: 'ownerUs', about_user: 'ownerAboutUser', about_project: 'ownerAboutProject' }
-    const VISIBILITY_LABELS = { shared: 'visShared', session: 'visSession', secret: 'visSecret' }
+    const VISIBILITY_LABELS = { shared: 'visShared', secret: 'visSecret' }
 // Provenance. `inferred` is the default and the least interesting value, but it is
 // still shown in the browser: the whole failure mode this label exists for is a
 // memory quietly claiming to be a quote.
@@ -2960,8 +2962,11 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
               res = await call('importMemories', payload)
             }
             const c = res.counts || {}
-            const skipped = (c.duplicate || 0) + (c.invalid || 0) + (c.dead || 0) + (c.expired || 0) + (c.downgraded || 0) + (c.sessionReset || 0)
-            setNotice(`${t('importDone')}: +${res.imported || 0} / −${skipped}`)
+            const skipped = (c.duplicate || 0) + (c.invalid || 0) + (c.dead || 0) + (c.expired || 0)
+            // `downgraded` entries did land in the library — calling them skipped would
+            // undercount what the user just imported, so they get their own suffix.
+            const adjusted = c.downgraded || 0
+            setNotice(`${t('importDone')}: +${res.imported || 0} / −${skipped}${adjusted ? ` · ${t('importAdjusted')}: ${adjusted}` : ''}`)
             if (res.engineWarning) setError(`${t('importEngineWarning')}: ${res.engineWarning}`)
             notifyMemoryWrite('import', browseLibId)
             await openBrowser(browseLibId)
@@ -3607,7 +3612,7 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
               title: t('visibilityLabel'),
               value: draft.visibility ?? f.visibility ?? 'shared',
               onChange: (e) => set('visibility', e.target.value),
-            }, ['shared', 'session', 'secret'].map((v) => h('option', { key: v, value: v }, enumText(t, VISIBILITY_LABELS, v)))),
+            }, ['shared', 'secret'].map((v) => h('option', { key: v, value: v }, enumText(t, VISIBILITY_LABELS, v)))),
             h('select', {
               style: { ...S.input, flex: '1 1 110px', minWidth: 0 },
               title: t('sourceLabel'),
@@ -4035,9 +4040,14 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
       // The conversation picker belongs to the Global tab only, so its (slow)
       // session listing is deferred until that tab is actually opened.
       React.useEffect(() => {
+        // Below, a render without a session returns before `pages` is built; an
+        // effect scheduled by that render still runs, and reading `pages` from it
+        // is a temporal-dead-zone error ("Cannot access 'pages' before
+        // initialization") shown inside the sidebar. No session, no panel — leave.
+        if (!sessionId) return
         if (pages[tabPage]?.key !== 'global' || sessionsLoaded || !loaded) return
         void loadSidebarSessions()
-      }, [tabPage, sessionsLoaded, loaded, loadSidebarSessions])
+      }, [sessionId, tabPage, sessionsLoaded, loaded, loadSidebarSessions])
 
       React.useEffect(() => { void refresh() }, [refresh])
       // Instant path: another pane of this window wrote a memory (browser add /
@@ -4292,6 +4302,20 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
         h('div', { style: S.tabBody }, pages[tabPage]?.node || null))
     }
 
+    // One card = one pair of switches. The card the user clicks, the binding
+    // written on confirm, and the two checkboxes the sidebar then shows are the
+    // same three ideas, so the mapping lives in one place: any drift shows up as
+    // a switch that says the opposite of the card that was picked.
+    const LAYERS_OF = {
+      none: { useLibrary: false, useGlobal: false },
+      auto: { useLibrary: true, useGlobal: false },
+      global: { useLibrary: false, useGlobal: true },
+      both: { useLibrary: true, useGlobal: true },
+    }
+    // Only the layers survive "remember my choice"; a one-off pick does not.
+    const PREFERENCE_OF = { none: 'off', auto: 'auto', global: 'global', both: 'both' }
+    const CARD_OF = { off: 'none', auto: 'auto', global: 'global', both: 'both' }
+
     function NewSessionGate({ ctx, t }) {
       const current = useCurrentSession(ctx)
       const list = useSessionList(ctx)
@@ -4300,6 +4324,10 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
       const checking = React.useRef(false)
       const [prompt, setPrompt] = React.useState(null)
       const [choice, setChoice] = React.useState('auto')
+      // The card picks the layers; this only picks *which* library carries them.
+      // Keeping the two apart is what stops an advanced pick from silently
+      // meaning "and whatever the folder policy says about the other switch".
+      const [pick, setPick] = React.useState('folder')
       const [libraryId, setLibraryId] = React.useState('')
       const [newName, setNewName] = React.useState('')
       const [dontShow, setDontShow] = React.useState(false)
@@ -4347,20 +4375,14 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
               return
             }
             if (st.settings?.newSessionPromptDismissed) {
-              // "Don't ask again" must actually honor the remembered choice —
-              // always creating a library here made the preference a no-op.
-              const pref = st.settings?.newSessionDefault || 'both'
-              if (pref === 'off') {
-                await call('initSession', { sessionId: current, cwd: summaryCwd, createLibrary: false })
-                await call('setSessionScope', { sessionId: current, useLibrary: false, useGlobal: false })
-              } else if (pref === 'auto') {
-                await call('initSession', { sessionId: current, cwd: summaryCwd, createLibrary: true })
-              } else {
-                // 'both' (and any legacy value): folder library plus both layers;
-                // the server still clamps against the folder policy.
-                await call('initSession', { sessionId: current, cwd: summaryCwd, createLibrary: true })
-                await call('setSessionScope', { sessionId: current, useLibrary: true, useGlobal: true })
-              }
+              // "Don't ask again" must actually honor the remembered choice.
+              // Writing only one of the two layers (or, as this branch used to,
+              // only the library) let the folder policy fill the missing switch,
+              // so the remembered answer was not the answer the sidebar showed.
+              const card = CARD_OF[String(st.settings?.newSessionDefault || 'both')] || 'both'
+              const layers = LAYERS_OF[card]
+              await call('initSession', { sessionId: current, cwd: summaryCwd, createLibrary: layers.useLibrary })
+              await call('setSessionScope', { sessionId: current, ...layers })
               decided.current.add(current)
               return
             }
@@ -4369,9 +4391,10 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
               cwd: summaryCwd || '',
               libraries: (st.libraries || []).filter((l) => l.scopeKey !== '__default__'),
               folder: st.folder || null,
-              defaultChoice: st.settings?.newSessionDefault || 'both',
+              defaultChoice: CARD_OF[String(st.settings?.newSessionDefault || 'both')] || 'both',
             })
-            setChoice(st.settings?.newSessionDefault || 'both')
+            setChoice(CARD_OF[String(st.settings?.newSessionDefault || 'both')] || 'both')
+            setPick('folder')
             setLibraryId((st.libraries || []).find((l) => l.scopeKey !== '__default__')?.id || '')
           } catch (e) {
             if (!cancelled) setError(String(e?.message || e))
@@ -4389,38 +4412,36 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
         setError('')
         try {
           if (dontShow) {
-            // Persist only choices the dismissed-branch understands; one-off
-            // picks like 'existing'/'new' must not become the default policy.
-            const preference = { none: 'off', auto: 'auto', both: 'both' }[choice]
+            // Persist only the layers the dismissed branch understands; a one-off
+            // library pick must not become the default policy.
+            const preference = PREFERENCE_OF[choice]
             await call('setSettings', {
               patch: preference
                 ? { newSessionPromptDismissed: true, newSessionDefault: preference }
                 : { newSessionPromptDismissed: true },
             })
           }
-          if (choice === 'existing' && libraryId) {
+          // The card decides the two layers, and it decides them on *every*
+          // branch. Leaving either one unwritten is what let ensureSession fill
+          // it from the folder policy, so "private memory only" came back as
+          // both switches checked in the sidebar.
+          const layers = LAYERS_OF[choice] || LAYERS_OF.none
+          // The advanced pick only says which library carries the private layer;
+          // with no private layer there is nothing to point at.
+          const target = layers.useLibrary ? pick : 'folder'
+          if (target === 'existing' && libraryId) {
             await call('initSession', { sessionId: prompt.sessionId, cwd: prompt.cwd, libraryId })
-          } else if (choice === 'new' && newName.trim()) {
+          } else if (target === 'new' && newName.trim()) {
             const lib = await call('createLibrary', { name: newName.trim(), cwd: prompt.cwd })
             await call('initSession', { sessionId: prompt.sessionId, cwd: prompt.cwd, libraryId: lib.id })
-          } else if (choice === 'none') {
-            // Explicit "no memory": do not create a private library for this
-            // conversation, and silence both sources for the session.
-            await call('initSession', { sessionId: prompt.sessionId, cwd: prompt.cwd, createLibrary: false })
-            await call('setSessionScope', { sessionId: prompt.sessionId, useLibrary: false, useGlobal: false })
-          } else if (choice === 'both') {
-            // Private and global together: the folder's own library plus the
-            // shared layer. The server still clamps against the folder policy.
-            await call('initSession', { sessionId: prompt.sessionId, cwd: prompt.cwd, createLibrary: true })
-            await call('setSessionScope', { sessionId: prompt.sessionId, useLibrary: true, useGlobal: true })
-          } else if (choice === 'global') {
-            // Global only: no private library for this conversation at all.
-            await call('initSession', { sessionId: prompt.sessionId, cwd: prompt.cwd, createLibrary: false })
-            await call('setSessionScope', { sessionId: prompt.sessionId, useLibrary: false, useGlobal: true })
           } else {
-            // "auto": create and bind a private library for this folder.
-            await call('initSession', { sessionId: prompt.sessionId, cwd: prompt.cwd, createLibrary: true })
+            // The folder's own library, created only when the private layer is
+            // actually on: "no memory" and "global only" must not mint one.
+            await call('initSession', { sessionId: prompt.sessionId, cwd: prompt.cwd, createLibrary: layers.useLibrary })
           }
+          // Always write both switches, so the sidebar reflects the card and not
+          // a policy default.
+          await call('setSessionScope', { sessionId: prompt.sessionId, ...layers })
           decided.current.add(prompt.sessionId)
           setPrompt(null)
         } catch (e) {
@@ -4478,7 +4499,7 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
         onClose: later,
         footer: [
           h(Button, { key: 'later', onClick: later, disabled: busy }, t('later')),
-          h(Button, { key: 'ok', onClick: confirm, disabled: busy || (choice === 'existing' && !libraryId) || (choice === 'new' && !newName.trim()), primary: true }, t('confirm')),
+          h(Button, { key: 'ok', onClick: confirm, disabled: busy || (pick === 'existing' && !libraryId) || (pick === 'new' && !newName.trim()), primary: true }, t('confirm')),
         ],
       },
       h('div', { style: { ...S.muted, lineHeight: 1.6 } }, t('memoryPromptBody')),
@@ -4521,11 +4542,17 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
       h('details', { style: { marginTop: 10 } },
         h('summary', { style: { ...S.muted, cursor: 'pointer' } }, t('advanced')),
         h('div', { style: { display: 'flex', flexDirection: 'column', gap: 8, marginTop: 8 } },
-          h('label', { style: S.row }, h('input', { type: 'radio', name: 'memu-choice', checked: choice === 'existing', onChange: () => setChoice('existing') }), t('chooseLibrary')),
-          choice === 'existing' ? h('select', { style: { ...S.input, marginLeft: 24 }, value: libraryId, onChange: (e) => setLibraryId(e.target.value) },
+          // A separate radio group from the cards above: choosing a library must
+          // not overwrite which layers the card above already asked for. That
+          // overwrite was the bug — clicking "existing library" sent the whole
+          // choice to 'existing', which the confirm branch did not handle, so no
+          // scope was written and the folder policy checked both switches.
+          h('label', { style: S.row }, h('input', { type: 'radio', name: 'memu-library', checked: pick === 'folder', onChange: () => setPick('folder') }), t('folderLibrary')),
+          h('label', { style: S.row }, h('input', { type: 'radio', name: 'memu-library', checked: pick === 'existing', onChange: () => setPick('existing') }), t('chooseLibrary')),
+          pick === 'existing' ? h('select', { style: { ...S.input, marginLeft: 24 }, value: libraryId, onChange: (e) => setLibraryId(e.target.value) },
             libraries.map((l) => h('option', { key: l.id, value: l.id }, l.name || l.id))) : null,
-          h('label', { style: S.row }, h('input', { type: 'radio', name: 'memu-choice', checked: choice === 'new', onChange: () => setChoice('new') }), t('createLibrary')),
-          choice === 'new' ? h('input', { style: { ...S.input, marginLeft: 24 }, placeholder: t('name'), value: newName, onChange: (e) => setNewName(e.target.value) }) : null)),
+          h('label', { style: S.row }, h('input', { type: 'radio', name: 'memu-library', checked: pick === 'new', onChange: () => setPick('new') }), t('createLibrary')),
+          pick === 'new' ? h('input', { style: { ...S.input, marginLeft: 24 }, placeholder: t('name'), value: newName, onChange: (e) => setNewName(e.target.value) }) : null)),
       h('label', { style: { ...S.row, marginTop: 12 } }, h('input', { type: 'checkbox', checked: dontShow, onChange: (e) => setDontShow(e.target.checked) }), t('rememberChoice')))
     }
 

package/lib/cycle.js

@@ -6,8 +6,13 @@ import {
 import { expireShortTerm } from './memory.js'
 import { requestPrivateConsolidation } from './private.js'
 import { startGlobalCuration } from './curator.js'
+import { runVisibilityMigrationPass } from './migrate.js'
 
 const SWEEP_MS = 5 * 60 * 1000
+// Long enough that the host has restored its session list and the agent objects
+// the fork needs, short enough that a user who opens the app and reads for a minute
+// still gets the catch-up before they type their next message.
+const STARTUP_SWEEP_MS = 8000
 
 function liveAgent(ctx, sessionId) {
   try {
@@ -40,16 +45,30 @@ export function runShortTermPass(_ctx, { now = Date.now(), log = () => {} } = {}
   }
 }
 
+// The host's answer when a conversation has been deleted. It is not transient —
+// retrying it is how a dead session used to be woken up once an hour forever.
+export function isGoneSessionError(message) {
+  return /session[^"]*".*" not found|no such session|ENOENT|session .*does not exist/i.test(String(message || ''))
+}
+
 // Sleep consolidation: after a conversation has been quiet for a while, the agent
 // gets one instruction to tidy the library it wrote during it. Failed attempts
 // back off, but never pretend that an unread transcript was consolidated.
-export async function runSleepPass(ctx, { now = Date.now(), log = () => {} } = {}) {
+//
+// Two things this pass must not do. It must not wake a conversation that no longer
+// exists: the host answers "session not found" for it forever, and the retry curve
+// tops out at one hour, so one deleted chat used to be retried for the life of the
+// install. And it must not read "there are new turns" as "there is something worth
+// remembering" — `assessConsolidationValue` inspects the transcript first, and a
+// session that only exchanged greetings is marked asleep instead of being forked.
+export async function runSleepPass(ctx, { now = Date.now(), log = () => {}, limit = 2 } = {}) {
   const settings = getSettings()
   if (settings.sleepConsolidation !== true) return { ran: 0, skipped: 'disabled' }
-  const idleMs = Math.max(1, Number(settings.sleepAfterIdleMinutes) || 20) * 60_000
-  let ran = 0
+  const idleMs = Math.max(1, Number(settings.sleepAfterIdleMinutes) || 3) * 60_000
+  const candidates = []
   for (const binding of listSessionBindings()) {
     if (!binding.lastTurnAt) continue
+    if (binding.sessionGone) continue
     const activeAt = Math.max(Date.parse(binding.lastTurnAt) || 0, Date.parse(binding.lastInboundAt) || 0, Date.parse(binding.lastAgentIdleAt) || 0)
     if (now - activeAt < idleMs) continue
     // Running includes a long-lived asynchronous tool. Waiting is not proof that
@@ -58,6 +77,14 @@ export async function runSleepPass(ctx, { now = Date.now(), log = () => {} } = {
     if (binding.inbound?.pending?.length) continue
     if (older(getLastSleepAt(binding.sessionId), binding.lastTurnAt) >= 0) continue
     if ((Date.parse(binding.sleepRetryAt || '') || 0) > now) continue
+    candidates.push({ binding, activeAt })
+  }
+  // Newest first: a catch-up run after the app was closed should tidy what the user
+  // just lived through, not a week-old chat that has already waited this long.
+  candidates.sort((a, b) => b.activeAt - a.activeAt)
+  const budget = Math.max(1, Math.min(10, Number(limit) || 2))
+  let ran = 0
+  for (const { binding } of candidates.slice(0, budget)) {
     if (binding.useLibrary === false) {
       setLastSleepAt(binding.sessionId)
       continue
@@ -75,19 +102,26 @@ export async function runSleepPass(ctx, { now = Date.now(), log = () => {} } = {
         setLastSleepAt(binding.sessionId, binding.lastTurnAt)
         setSessionBinding(binding.sessionId, { sleepRetryAt: null, sleepAttempts: 0, lastSleepError: null })
         ran += 1
+      } else if (isGoneSessionError(result?.error)) {
+        setSessionBinding(binding.sessionId, { sessionGone: true, sessionGoneAt: new Date(now).toISOString(), sleepRetryAt: null, sleepAttempts: 0, lastSleepError: String(result.error) })
+        log(`sleep consolidation dropped ${binding.sessionId}: the conversation no longer exists`)
       } else {
         const attempts = Number(binding.sleepAttempts || 0) + 1
         setSessionBinding(binding.sessionId, { sleepAttempts: attempts, lastSleepError: result?.error || 'not settled', sleepRetryAt: new Date(now + Math.min(60, 2 ** Math.min(attempts, 6)) * 60_000).toISOString() })
         log(`sleep consolidation skipped for ${binding.sessionId}: ${result?.error || 'not queued'}`)
       }
     } catch (error) {
+      if (isGoneSessionError(error?.message)) {
+        setSessionBinding(binding.sessionId, { sessionGone: true, sessionGoneAt: new Date(now).toISOString(), sleepRetryAt: null, sleepAttempts: 0, lastSleepError: String(error.message) })
+        continue
+      }
       // A missing service or transient file failure can heal without a new turn.
       const attempts = Number(binding.sleepAttempts || 0) + 1
       setSessionBinding(binding.sessionId, { sleepAttempts: attempts, lastSleepError: String(error?.message || error), sleepRetryAt: new Date(now + Math.min(60, 2 ** Math.min(attempts, 6)) * 60_000).toISOString() })
       log(`sleep consolidation failed for ${binding.sessionId}: ${error?.message || error}`)
     }
   }
-  return { ran }
+  return { ran, considered: candidates.length }
 }
 
 // Background global curation: turn the conversations that happened since the last
@@ -178,7 +212,11 @@ export async function runCyclePasses(ctx, options = {}) {
   const sleep = await runSleepPass(ctx, options)
   const curate = await runCurationPass(ctx, options)
   const libraries = runLibraryHousekeeping(ctx, options)
-  return { shortTerm, sleep, curate, libraries }
+  // A library can still be on disk in the removed `session` format when the plugin
+  // updated mid-flight. Reads are already normalized, so this only keeps the files in
+  // step with the code (see lib/migrate.js); it is cheap and idempotent.
+  const migrated = runVisibilityMigrationPass({ log: options.log })
+  return { shortTerm, sleep, curate, libraries, migrated }
 }
 
 // DSH has no host scheduler a plugin can register a *global* job with
@@ -201,6 +239,14 @@ export function registerCycle(ctx, { log = () => {} } = {}) {
       running = false
     }
   }
+  // One catch-up sweep shortly after load. The sweep timer only exists while the app
+  // is open, so a conversation that ended while it was closed used to wait for the
+  // next idle window — and the next message always resets that clock, which is how a
+  // whole evening could pass without a single consolidation. The delay lets the host
+  // finish restoring sessions and agents first; the pass itself is bounded (two
+  // sessions) so a long list of stale bindings cannot turn startup into a stampede.
+  const startup = setTimeout(() => { void tick() }, STARTUP_SWEEP_MS)
+  startup.unref?.()
   // Property access on an uninjected service throws in cordis, so the probe itself
   // is guarded; a host without the timer service falls back instead of failing.
   let scoped = null
@@ -210,9 +256,9 @@ export function registerCycle(ctx, { log = () => {} } = {}) {
     // clearInterval() on it is a silent no-op and the sweep would keep running
     // after plugin unload/HMR. Call the disposer.
     const dispose = scoped.interval(() => { void tick() }, SWEEP_MS)
-    return () => { try { dispose?.() } catch {} }
+    return () => { try { clearTimeout(startup) } catch {} try { dispose?.() } catch {} }
   }
   const timer = setInterval(() => { void tick() }, SWEEP_MS)
   timer.unref?.()
-  return () => clearInterval(timer)
+  return () => { clearTimeout(startup); clearInterval(timer) }
 }

package/lib/inbound.js

@@ -125,6 +125,10 @@ export function ingestInboundBatch({ sessionId, batch, session, ctx, now = Date.
   setSessionBinding(sessionId, {
     inbound: { ...before, pending, retryAt: null }, lastInboundAt: at, lastTurnAt: at,
     lastInboundError: null,
+    // A message just came out of this conversation, so it exists. Clears the mark
+    // the sleep pass puts on a session the host reported as deleted (a fork/session
+    // can be recreated under the same id after a restore).
+    sessionGone: false, sessionGoneAt: null,
   })
   flushState()
   if (session) sessions.set(sessionId, session)
@@ -139,7 +143,11 @@ export function noteNativeUserMessages(sessionId, messages, { now = Date.now() }
   const keys = messages.filter(message => message?.source?.kind === 'user' && message.role === 'user' && typeof message.id === 'string')
     .map(message => messageKey({ id: message.id, context: binding.memoryContext }))
   const seen = [...new Set([...before.seen, ...keys])].slice(-MAX_SEEN)
-  setSessionBinding(sessionId, { inbound: { ...before, seen, pending: before.pending.filter(item => !keys.includes(item.key)) }, lastTurnAt: new Date(now).toISOString() })
+  setSessionBinding(sessionId, {
+    inbound: { ...before, seen, pending: before.pending.filter(item => !keys.includes(item.key)) },
+    lastTurnAt: new Date(now).toISOString(),
+    sessionGone: false, sessionGoneAt: null,
+  })
 }
 
 export function hasPendingInbound(sessionId) {

package/lib/index.js

@@ -1,5 +1,6 @@
 import { registerTools } from './tools.js'
 import { registerInjection } from './inject.js'
+import { registerPresetAttachment } from './preset-scope.js'
 import { registerRpc } from './rpc.js'
 import { registerCycle } from './cycle.js'
 import { syncPromptDefaults } from './prompts.js'
@@ -36,6 +37,17 @@ function startEngineBootstrap(ctx) {
 }
 
 export function apply(ctx, config) {
+  // A conversation that names an agent preset composes its model-facing plugin set from
+  // that preset's cordis.yml alone, and that subtree never delivers `agent/pre-step` to
+  // this instance — so nothing here runs for those conversations. `lib/preset-scope.js`
+  // walks the live agent registry and attaches the injection listener on each such
+  // agent's own context instead. No preset file is touched.
+  //
+  // `config.preset === true` remains for the opposite case: a user who *does* list this
+  // plugin inside a preset gets a second instance in the same process, and that instance
+  // must not re-register the process-global surfaces (RPC prefix, idle sweep, engine
+  // installer). The tools and the pre-step hook are what such a mount needs.
+  const inPreset = config?.preset === true
   if (applied.has(ctx)) {
     try { ctx.logger?.warn?.('dsh-memu-memory: apply() already ran on this context; skipping') } catch {}
     return
@@ -72,13 +84,22 @@ export function apply(ctx, config) {
     ctx.effect(() => disposeInjection, 'dsh-memu-memory: injection')
   }
 
-  registerRpc(ctx)
-  startEngineBootstrap(ctx)
-
-  const disposeCycle = registerCycle(ctx, {
+  const disposeAttach = registerPresetAttachment(ctx, {
     log: (message) => { try { ctx.logger?.warn?.(`dsh-memu-memory: ${message}`) } catch {} },
   })
   if (typeof ctx.effect === 'function') {
+    ctx.effect(() => disposeAttach, 'dsh-memu-memory: preset attachment')
+  }
+
+  if (!inPreset) {
+    registerRpc(ctx)
+    startEngineBootstrap(ctx)
+  }
+
+  const disposeCycle = inPreset ? null : registerCycle(ctx, {
+    log: (message) => { try { ctx.logger?.warn?.(`dsh-memu-memory: ${message}`) } catch {} },
+  })
+  if (disposeCycle && typeof ctx.effect === 'function') {
     ctx.effect(() => disposeCycle, 'dsh-memu-memory: cycle')
   }
 

package/lib/inject.js

@@ -337,8 +337,8 @@ export function buildAnniversary(sessionId, binding, now = new Date()) {
   const dayKey = `${now.getFullYear()}-${md}`
   const hits = Object.entries(index.entries || {})
     // Same visibility rules as every other injection surface: no archived /
-    // suppressed / expired / pending_review, no secret bodies in the prompt, and
-    // session-scoped entries only in the conversation that wrote them.
+    // suppressed / expired / pending_review, no secret bodies in the prompt, and a
+    // context-scoped entry only where the conversation's scope matches it.
     .filter(([, e]) => salientDateFires(e.salientDate, now) && isMemoryEligible(e, { automatic: true, now: now.getTime() }))
     .filter(([, e]) => e.visibility !== 'secret')
     .filter(([, e]) => visibleToSession(e, sessionId))
@@ -691,6 +691,39 @@ export function createMemoryMessage(text) {
   })
 }
 
+/**
+ * Deliver the memory rules as a message when the system prompt cannot hold them.
+ *
+ * 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.
+ */
+function withGuideMessage(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 (!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)] }
+  } catch (error) {
+    try { ctx.logger?.warn?.(`dsh-memu-memory: guide message skipped: ${error?.message || error}`) } catch {}
+    return decision
+  }
+}
+
 async function injectInboundForStep({ agent, decision, turn, signal, log, ctx }) {
   const sessionId = agent.session.header.id
   const before = getSessionBinding(sessionId)
@@ -974,36 +1007,48 @@ function sectionText(ctx, key, context) {
   }
 }
 
-export function registerInjection(ctx) {
+export function registerInjection(ctx, options = {}) {
   const disposers = []
-  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 {}
+  // `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()
     try {
-      return await injectForStep({
+      const injected = await injectForStep({
         ...payload,
         decision,
         ctx,
         log: (message) => { try { ctx.logger?.warn?.(`dsh-memu-memory: ${message}`) } catch {} },
       })
+      return guideInMessage ? withGuideMessage(ctx, payload, injected) : 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 {}