@yolk_vat-y/dsh-project-memory 0.5.0 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolk_vat-y/dsh-project-memory",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Persistent project memory for dsh agents: index docs (PDF/Markdown/text) and code symbols into a searchable per-workspace store, recall them with cited sources, and keep experience entries (problems -> solutions) searchable on demand.",
   "type": "module",
   "main": "src/index.js",
@@ -17,7 +17,7 @@
     "url": "https://github.com/00080000/dsh-project-memory.git"
   },
   "scripts": {
-    "test": "node test/run-test.mjs && node test/taskbridge.test.mjs && node test/insight-store.test.mjs && node test/reflection-pipeline.test.mjs && node test/auto-inject.test.mjs && node test/insight-actions.test.mjs",
+    "test": "node test/run-test.mjs && node test/taskbridge.test.mjs && node test/insight-store.test.mjs && node test/reflection-pipeline.test.mjs && node test/auto-inject.test.mjs && node test/insight-actions.test.mjs && node test/host-contract.test.mjs",
     "build:client": "tsdown"
   },
   "keywords": [

package/src/auto-inject.js

@@ -1,10 +1,10 @@
 // PR 2 静默注入引擎（entry 常驻块 + relevance 门控）
 // 安全约定：
 //  - 纯函数 buildInjection 可单测；
-//  - wrapLlmStream 仅在 resolver 给出项目 root 时才会真正动 messages，
-//    任何异常/禁用/无 root → 原样透传（零副作用），绝不让宿主请求受影响。
-//  - “静默注入”文本带 [Memory Inject] 前缀，落在最后一条 user message 内容块里；
-//    指纹去重保证内容未变不重复追加（变更由宿主消息历史自然保留到压缩前）。
+//  - 唯一接线点是宿主 agent/pre-step 瀑布事件；任何异常/无会话 cwd → 交回合法决策，
+//    绝不让宿主请求受影响（宿主直接读 decision.kind，返回 undefined 会崩掉整步）。
+//  - “静默注入”文本带 [Memory Inject] 前缀，作为一条 plugin source 的 user 消息追加；
+//    按会话指纹去重，内容未变不重复追加。
 import { createHash } from 'node:crypto'
 import { createUserMessage } from '@deepseek-ai/dsh-llm'
 import { ProjectMemoryStore } from './store.js'
@@ -25,6 +25,10 @@ export function cfgEngine(config) {
     maxTokens: typeof c.maxTokens === 'number' ? c.maxTokens : 400,
     entryMaxInsights: typeof c.entryMaxInsights === 'number' ? c.entryMaxInsights : 6,
     relevanceMin: typeof c.relevanceMin === 'number' ? c.relevanceMin : 0.25,
+    // resident 任务卡最多显示几个"编辑中"文件（纯写权重，最近写优先）
+    editedMax: typeof c.editedMax === 'number' ? c.editedMax : 3,
+    // 模型自己写/维护任务清单后、尚无新人类消息时，不把任务卡再回声给模型（省 token）
+    skipEchoSelfTodo: c.skipEchoSelfTodo !== false,
   }
 }
 
@@ -62,14 +66,40 @@ function linesOf(list) {
   return out
 }
 
-/** 任务卡 + 非草稿任务级 insights 摘要（常驻块主体）。 */
-export function buildEntryContent(task, cfg) {
+/** 任务卡上"编辑中"文件（写过、最近写优先，最多 max 个）。 */
+export function editedFiles(task, max) {
+  if (!task || !task.fileMeta) return []
+  const meta = task.fileMeta
+  // task.files 已由 taskbridge 保持热序（写过在前、按 lastWriteAt 倒序）
+  return (task.files || []).filter((f) => meta[f] && meta[f].lastWriteAt).slice(0, max)
+}
+
+/**
+ * 是否回声 resident 任务卡：最近一次推进是模型自己 todo 写步骤、且之后没有新人类消息时，
+ * 不回声（模型刚写的东西再喂回去 = 噪音/浪费 token）。保留相关 insights 注入不变。
+ */
+export function shouldEchoTaskCard(task, cfg) {
+  if (!task) return false
+  const c = cfg || {}
+  if (c.skipEchoSelfTodo === false) return true
+  const lt = task.lastTodoAt
+  const lh = task.lastHumanAt
+  if (lt && lh) return !(lt > lh)
+  return true
+}
+
+/** 任务卡 + 非草稿任务级 insights 摘要（常驻块主体）。
+ * withEdited=false 用于去重指纹：排除随写文件高频变化的“编辑中”行。 */
+export function buildEntryContent(task, cfg, { withEdited = true } = {}) {
   if (!task) return ''
+  const c = cfg || {}
   const steps = (task.steps || []).map((s) => (typeof s === 'string' ? s : s.content || s.text || '').slice(0, 80))
   const card = [`任务: ${task.title || '(untitled)'}`, `进度: ${steps.filter((s) => true).length ? `${steps.length} 步` : ''}`, ...steps.slice(0, 12).map((s, i) => `  ${i + 1}. ${s}`)]
   const insights = linesOf(task.insights)
+  const edited = editedFiles(task, c.editedMax || 3)
   const parts = [...card]
-  if (insights.length) parts.push(`任务记忆:`, ...insights.slice(0, cfg.entryMaxInsights || 6))
+  if (withEdited && edited.length) parts.push(`  编辑中: ${edited.join(', ')}`)
+  if (insights.length) parts.push(`任务记忆:`, ...insights.slice(0, c.entryMaxInsights || 6))
   return parts.join('\n')
 }
 
@@ -122,89 +152,61 @@ export function buildInjection(opts) {
     labels.push(label)
     if (parts.join('\n').length > budgetChars) break
   }
-  // 常驻块文本（内容哈希由 wrapper 判“是否已注入过”）
-  const entry = task ? buildEntryContent(task, cfg) : ''
+  // 常驻块文本。去重指纹只看稳定内容（任务标题/步骤/insights + 相关 insights）：
+  // “编辑中”随每次写文件变化，若参与指纹会导致每写一个文件就重发整块（噪音 + token 浪费）。
+  const echo = shouldEchoTaskCard(task, cfg)
+  const entry = echo ? buildEntryContent(task, cfg) : ''
+  const entryStable = echo ? buildEntryContent(task, cfg, { withEdited: false }) : ''
   const total = [entry, ...parts].filter(Boolean)
   if (!total.length) return { text: '', labels: [] }
-  let text = total.join('\n')
-  if (text.length > budgetChars) text = text.slice(0, budgetChars) + '\n…(截断)'
-  return { text, labels }
+  const clamp = (t) => (t.length > budgetChars ? t.slice(0, budgetChars) + '\n…(截断)' : t)
+  const dedupeText = clamp([entryStable, ...parts].filter(Boolean).join('\n'))
+  return { text: clamp(total.join('\n')), labels, dedupeText }
 }
 
-/**
- * 包装 llm.stream。resolver(ctx, config) 返回项目 root；返回 null → 完全透传。
- * opts.state 持有“当前注入指纹”（跨请求去重）。
+/** 注册 agent/pre-step 监听，向每步请求的 enter 决策追加记忆消息（默认开）。
+ * 宿主瀑布事件签名为 (payload, next)：payload.agent.session 提供会话（header.cwd=项目根）。
+ * 任何异常/无会话 cwd → 原样返回默认决策，零副作用，绝不让宿主请求受影响。
  */
-export function wrapLlmStream(streamFn, config, { resolveRoot, state, llmName = 'llm' } = {}) {
-  const auto = (config && config.autoContext) || {}
-  if (auto.enabled === false) return streamFn
-  const orig = typeof streamFn === 'function' ? streamFn : () => {}
-  const cfg = cfgEngine(config)
-  const mem = state || {}
-  return async function* wrapped(params) {
-    try {
-      const resolved = resolveRoot ? resolveRoot(config) : null
-      const root = typeof resolved === 'string' ? resolved : (resolved && resolved.root) || null
-      const sessionId = resolved && typeof resolved === 'object' ? resolved.sessionId || null : null
-      if (root) {
-        const query = lastUserText(params && params.messages)
-        const store = new ProjectMemoryStore(memoryRootFor(root, config.memoryDir)).load()
-        const globalStore = new GlobalStore(cfgInsight(config).globalFile || defaultGlobalFile()).load()
-        const sid = sessionId || null
-        const boundTaskId = sid && store.getBoundTaskId(sid) ? store.getBoundTaskId(sid) : null
-        const task = boundTaskId ? store.getTask(boundTaskId) : null
-        const built = buildInjection({ query, task, store, globalStore, projectTagsList: projectTags(root), cfg })
-        const fp = fingerprint(built.text)
-        if (built.text && fp !== mem.lastFp) {
-          const last = params.messages && params.messages[params.messages.length - 1]
-          if (last && last.role === 'user') {
-            const content = Array.isArray(last.content) ? last.content : []
-            content.push({ type: 'text', text: `\n\n${INJECT_MARK} ${llmName}\n${built.text}` })
-            last.content = content
-            mem.lastFp = fp
-            if (!mem.loggedFire) {
-              mem.loggedFire = true
-              console.log(`[dsh-project-memory] auto-context: FIRST injection fired (${built.text.length} chars, root=${root}${sessionId ? `, session=${sessionId}` : ''})`)
-            }
-          }
-        }
-      }
-    } catch (err) {
-      console.error(`[dsh-project-memory] auto-inject skipped: ${err?.message || err}`)
-    }
-    // 无论注入与否都原样走宿主 stream（异常同样原样传播）
-    yield* orig(params)
-  }
-}
-
-/** 注册 agent/pre-step 监听，向每步请求的 enter 决策追加记忆消息（默认开）。 */
 export function installAutoInject(ctx, config) {
   const auto = (config && config.autoContext) || {}
   if (auto.enabled === false) return
   const cfg = cfgEngine(config)
-  const mem = {}
-  ctx.on('agent/pre-step', async (next, { agent, session }) => {
-    const decision = await next()
-    if (!decision || decision.kind !== 'enter') return decision
-    const root = session?.header?.cwd
-    const sessionId = session?.id
-    if (!root) return decision
+  // 每个会话一份“上次注入指纹”。用单个变量会让并发会话互相抑制注入。
+  const lastFpBySession = new Map()
+  const LAST_FP_MAX = 200
+  ctx.on('agent/pre-step', async (payload, next) => {
+    // 宿主契约是 waterfall(payload, next)，next 一定存在；但一旦宿主版本漂移、或事件被当
+    // 普通事件调用，next 缺失会让本监听器 reject（历史事故正是 `next is not a function`）。
+    // 更致命的是返回 undefined：宿主 agent.ts 直接读 `decision.kind`，会崩掉整步 → 无法回复。
+    // 因此两种情况都退化为一个合法的 enter 决策，绝不让宿主请求受影响。
+    const fallback = () => ({ kind: 'enter', messages: (payload && payload.messages) || [] })
+    const decision = typeof next === 'function' ? await next() : fallback()
+    if (!decision) return fallback()
+    if (decision.kind !== 'enter') return decision
     try {
+      const agent = payload && payload.agent
+      const session = agent && agent.session
+      const root = session && session.header && session.header.cwd
+      const sessionId = session && session.id
+      if (!root || !sessionId) return decision
       const query = lastUserText(decision.messages)
       const store = new ProjectMemoryStore(memoryRootFor(root, config.memoryDir)).load()
       const globalStore = new GlobalStore(cfgInsight(config).globalFile || defaultGlobalFile()).load()
-      const boundTaskId = sessionId && store.getBoundTaskId(sessionId) ? store.getBoundTaskId(sessionId) : null
+      const boundTaskId = store.getBoundTaskId(sessionId) ? store.getBoundTaskId(sessionId) : null
       const task = boundTaskId ? store.getTask(boundTaskId) : null
       const built = buildInjection({ query: query || '', task, store, globalStore, projectTagsList: projectTags(root), cfg })
-      const fp = fingerprint(built.text)
-      if (built.text && fp !== mem.lastFp) {
-        const last = decision.messages && decision.messages[decision.messages.length - 1]
-        if (last && last.role === 'user') {
-          const content = Array.isArray(last.content) ? last.content : []
-          content.push({ type: 'text', text: `\n\n${INJECT_MARK} auto-context\n${built.text}` })
-          last.content = content
-          mem.lastFp = fp
-        }
+      const fp = fingerprint(built.dedupeText ?? built.text)
+      if (built.text && fp !== lastFpBySession.get(sessionId)) {
+        // 以宿主 createUserMessage 构造的完整 user 消息追加（带 id/source，plan-mode narration 同款）。
+        // 裸 {role,content} 消息缺 source 会让宿主逐条读 message.source.kind 时崩溃。
+        lastFpBySession.set(sessionId, fp)
+        if (lastFpBySession.size > LAST_FP_MAX) lastFpBySession.delete(lastFpBySession.keys().next().value)
+        const injectMessage = createUserMessage({
+          content: [{ type: 'text', text: `\n\n${INJECT_MARK} auto-context\n${built.text}` }],
+          source: { kind: 'plugin', plugin: 'dsh-project-memory', form: 'notice', summary: `记忆注入 ${built.text.length} 字符` },
+        })
+        return { ...decision, messages: [...decision.messages, injectMessage] }
       }
     } catch (err) {
       console.error(`[dsh-project-memory] auto-inject skipped: ${err?.message || err}`)

package/src/client/TaskComponents.tsx

@@ -2,7 +2,7 @@
  * Task Panel Presentational 组件 — MiniBar（折叠迷你条）与 TaskCard（任务卡）。
  * 纯渲染 + 卡片局部行内编辑/拖拽状态，动作经 props 回调交给容器（TaskPanel.tsx）。
  */
-import { useRef, useState } from 'react'
+import { useEffect, useLayoutEffect, useRef, useState } from 'react'
 import {
   Button,
   IconChevronDownOutline14,
@@ -45,6 +45,75 @@ function StepIcon({ status }: { status: TaskStep['status'] }) {
   return <span className={css.stepPending} />
 }
 
+/**
+ * 双击判定窗口（ms）。
+ * 单击（如卡片展开/收起）会延迟该时长执行：若期间收到第二次点击则按“双击”处理并取消单击，
+ * 从而避免“第一下先展开/收起、布局位移后第二下点不到目标”的问题。
+ * 数值是可感知与可靠性的折中：太小慢速双击会失效，太大单击会显“肉”。
+ */
+const CLICK_SINGLE_DELAY_MS = 250
+
+/**
+ * 行内自适应高度文本编辑器（textarea）。
+ * 编辑体验与单行输入一致（Enter 提交 / Shift+Enter 换行 / Esc 取消 / 失焦提交），
+ * 但高度随内容自动增长（按实际渲染行高测量），最多 maxRows 行后内部滚动，
+ * 解决长步骤/长任务名只能挤在一行里横向滚动编辑的问题。
+ */
+interface InlineEditorProps {
+  value: string
+  className?: string
+  maxRows?: number
+  onValueChange: (value: string) => void
+  onCommit: () => void
+  onCancel: () => void
+}
+
+function InlineEditor({ value, className, maxRows = 8, onValueChange, onCommit, onCancel }: InlineEditorProps) {
+  const ref = useRef<HTMLTextAreaElement>(null)
+
+  // 在绘制前按真实内容测量并写死高度：内容 <= maxRows 行时刚好包住，超出后内部滚动。
+  useLayoutEffect(() => {
+    const el = ref.current
+    if (!el) return
+    el.style.height = 'auto'
+    const cs = getComputedStyle(el)
+    const lineHeight = parseFloat(cs.lineHeight) || 20
+    const padV = (parseFloat(cs.paddingTop) || 0) + (parseFloat(cs.paddingBottom) || 0)
+    const borderV = (parseFloat(cs.borderTopWidth) || 0) + (parseFloat(cs.borderBottomWidth) || 0)
+    const cap = maxRows * lineHeight + padV + borderV
+    const height = Math.min(el.scrollHeight, cap)
+    el.style.height = `${height}px`
+    el.style.overflowY = el.scrollHeight > cap ? 'auto' : 'hidden'
+  }, [value, maxRows])
+
+  return (
+    <textarea
+      ref={ref}
+      className={className}
+      rows={1}
+      value={value}
+      autoFocus
+      spellCheck={false}
+      onChange={(e) => onValueChange(e.target.value)}
+      onFocus={(e) => {
+        // 光标放到末尾，便于直接在原文后继续输入
+        const len = e.target.value.length
+        e.target.setSelectionRange(len, len)
+      }}
+      onBlur={onCommit}
+      onKeyDown={(e) => {
+        if (e.key === 'Enter' && !e.shiftKey) {
+          e.preventDefault()
+          onCommit()
+        } else if (e.key === 'Escape') {
+          e.preventDefault()
+          onCancel()
+        }
+      }}
+    />
+  )
+}
+
 interface MiniBarProps {
   label: string
   hint: string
@@ -163,29 +232,66 @@ export function TaskCard({
     onRename(value)
   }
 
+  // —— 卡片头单击(展开/收起)与双击(编辑任务名)的时序判定 ——
+  // 单击动作延迟 CLICK_SINGLE_DELAY_MS 执行；若在窗口内收到第二次点击，取消单击、
+  // 命中任务名则直接进入编辑，避免“第一下已展开/收起、布局位移、第二下点不到任务名”。
+  const headClickTimer = useRef<number | null>(null)
+  // 编辑状态下，点卡片头任意处会先触发失焦提交；该次点击不应再当作“切换展开”的单击。
+  const suppressHeadClick = useRef(false)
+  useEffect(() => () => {
+    if (headClickTimer.current !== null) window.clearTimeout(headClickTimer.current)
+  }, [])
+
+  const handleHeadClick = (e: React.MouseEvent<HTMLButtonElement>) => {
+    if (suppressHeadClick.current) {
+      // 上一次 mousedown 落在标题编辑框内（失焦提交产生），吞掉这次点击，不切换展开
+      suppressHeadClick.current = false
+      return
+    }
+    if (titleEdit !== null) return
+    const target = e.target as HTMLElement
+    const onTitle = isBound && target.closest('[data-card-title]') !== null
+    if (headClickTimer.current !== null) {
+      // 第二次点击 → 双击：取消待执行的单击动作
+      window.clearTimeout(headClickTimer.current)
+      headClickTimer.current = null
+      if (onTitle) setTitleEdit({ value: String(task.title ?? '') })
+      else onToggleExpand()
+      return
+    }
+    headClickTimer.current = window.setTimeout(() => {
+      headClickTimer.current = null
+      onToggleExpand()
+    }, CLICK_SINGLE_DELAY_MS)
+  }
+
   return (
     <article data-task-id={task.id} className={`${css.card}${isBound ? ` ${css.cardBound}` : ''}`}>
       <button
         className={css.cardHead}
-        onClick={() => { if (titleEdit !== null) return; onToggleExpand() }}
+        onClick={handleHeadClick}
+        onMouseDownCapture={() => {
+          // 标题编辑中，点击卡片头任意处都会先失焦提交；标记该次点击以在 onClick 中吞掉，
+          // 避免“改名提交一下、卡片又收起/展开一下”的误切换。
+          if (titleEdit !== null) suppressHeadClick.current = true
+        }}
+        onDoubleClick={(e) => e.preventDefault()}
         aria-expanded={expanded}
       >
         <div className={css.cardTitleRow}>
           {isBound && <span className={css.boundBadge}>{t('task.current')}</span>}
           {isBound && titleEdit !== null ? (
-            <input
-              className={css.stepInput}
+            <InlineEditor
+              className={css.editorArea}
               value={titleEdit.value}
-              autoFocus
-              onChange={(e) => setTitleEdit({ value: e.target.value })}
-              onBlur={commitTitleEdit}
-              onKeyDown={(e) => {
-                if (e.key === 'Enter') commitTitleEdit()
-                else if (e.key === 'Escape') setTitleEdit(null)
-              }}
+              maxRows={4}
+              onValueChange={(value) => setTitleEdit({ value })}
+              onCommit={commitTitleEdit}
+              onCancel={() => setTitleEdit(null)}
             />
           ) : (
             <span
+              data-card-title
               className={`${css.cardTitle}${isBound ? ` ${css.cardTitleEditable}` : ''}`}
               title={isBound ? t('task.title-edit') : undefined}
               onDoubleClick={(e) => {
@@ -252,16 +358,13 @@ export function TaskCard({
                           <StepIcon status={step.status} />
                         )}
                         {stepIsEditing ? (
-                          <input
-                            className={css.stepInput}
+                          <InlineEditor
+                            className={css.editorArea}
                             value={stepEdit!.value}
-                            autoFocus
-                            onChange={(e) => setStepEdit({ index: i, value: e.target.value })}
-                            onBlur={() => commitStepEdit(i)}
-                            onKeyDown={(e) => {
-                              if (e.key === 'Enter') commitStepEdit(i)
-                              else if (e.key === 'Escape') setStepEdit(null)
-                            }}
+                            maxRows={10}
+                            onValueChange={(value) => setStepEdit({ index: i, value })}
+                            onCommit={() => commitStepEdit(i)}
+                            onCancel={() => setStepEdit(null)}
                           />
                         ) : (
                           <span

package/src/client/TaskPanel.module.css

@@ -280,6 +280,7 @@
   line-height: 20px;
   color: var(--dsw-alias-label-secondary);
   word-break: break-word;
+  white-space: pre-wrap;
 }
 .stepContentDone {
   color: var(--dsw-alias-label-dimmed);
@@ -430,7 +431,7 @@
   outline: 1px dashed var(--dsw-alias-border-l3, rgba(127,127,127,.4));
   outline-offset: 1px;
 }
-/* 行内编辑框（步骤/标题共用，单行 input） */
+/* 行内编辑框（步骤/标题共用，单行 input，仍被 MemoryView 表单复用） */
 .stepInput {
   flex: 1 1 auto;
   min-width: 0;
@@ -446,6 +447,33 @@
   padding: 0 5px;
 }
 
+/* 任务卡行内编辑器（textarea，按内容自适应增高；高度由 JS 测量写死，
+   内容超过 maxRows 行后内部滚动，避免长步骤/长任务名单行横向拖拽编辑） */
+.editorArea {
+  flex: 1 1 0%;
+  min-width: 0;
+  box-sizing: border-box;
+  font-family: inherit;
+  font-size: 12px;
+  line-height: 20px;
+  color: var(--dsw-alias-label-primary);
+  background: var(--dsw-alias-bg-base, transparent);
+  border: 1px solid var(--dsw-alias-border-l3, rgba(127,127,127,.45));
+  border-radius: 5px;
+  padding: 2px 5px;
+  margin: 0;
+  resize: none;
+  overflow: hidden;
+  vertical-align: middle;
+  cursor: text;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+.editorArea:focus {
+  outline: none;
+  border-color: var(--dsw-alias-border-l3, rgba(127,127,127,.6));
+}
+
 /* —— 步骤拖拽重排：源行半透明 —— */
 .stepDragging {
   opacity: 0.3;

package/src/index.js

@@ -118,14 +118,22 @@ export function apply(ctx, config) {
   installAutoInject(ctx, config)
 
   if (config.autoIndexOnFirstUse) {
-    ctx.effect(async () => {
-      const root = process.cwd()
-      try {
-        watchManager.addRoot(root)
-        const report = await indexRepository(ctx, config, root)
-        console.log(`[dsh-project-memory] ${report}`)
-      } catch (err) {
-        console.error(`[dsh-project-memory] auto-index failed for ${root}: ${err.message}`)
+    // effect 回调必须同步并返回 disposer；异步体独立执行，用 cancelled 标志避免卸载后再写日志
+    ctx.effect(() => {
+      let cancelled = false
+      const run = async () => {
+        const root = process.cwd()
+        try {
+          watchManager.addRoot(root)
+          const report = await indexRepository(ctx, config, root)
+          if (!cancelled) console.log(`[dsh-project-memory] ${report}`)
+        } catch (err) {
+          if (!cancelled) console.error(`[dsh-project-memory] auto-index failed for ${root}: ${err.message}`)
+        }
+      }
+      run()
+      return () => {
+        cancelled = true
       }
     })
   }

package/src/lazy.js

@@ -1,7 +1,7 @@
 import path from 'node:path'
 import { tmpdir } from 'node:os'
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
-import { isSupportedCode, isSupportedDoc, memoryRootFor, relativePath, sha256OfFile, storeKey } from './util/fs.js'
+import { existsSync, readdirSync, statSync } from 'node:fs'
+import { isSupportedCode, isSupportedDoc, memoryRootFor, readFileForIndex, relativePath, storeKey } from './util/fs.js'
 import { buildDocEntries } from './doc-pipeline.js'
 import { scanSymbols } from './symbols.js'
 import { linkEntries } from './link.js'
@@ -88,12 +88,13 @@ export async function indexFile(ctx, config, filePath, watchManager = null) {
   const existing = store.fileRecord(rel)
   let hash
   let size
+  let buffer
   let entries
   try {
     if (isSupportedCode(ext) && config.maxFileSizeMb && statSync(filePath).size > config.maxFileSizeMb * 1024 * 1024) {
       return false
     }
-    ;({ hash, size } = await sha256OfFile(filePath))
+    ;({ hash, size, buffer } = readFileForIndex(filePath))
   } catch {
     return false
   }
@@ -105,7 +106,7 @@ export async function indexFile(ctx, config, filePath, watchManager = null) {
   }
 
   if (isSupportedCode(ext)) {
-    entries = scanSymbols(rel, filePath, readFileSync(filePath, 'utf8'))
+    entries = scanSymbols(rel, filePath, buffer.toString('utf8'))
     onFileObserved(store, rel, filePath, config, root)
     return store.commit((s) => {
       s.markFile(rel, { sha256: hash, size, type: 'code', indexedAt: new Date().toISOString() })

package/src/setup/taskbridge.js

@@ -8,6 +8,8 @@ import { findProjectRoot } from '../lazy.js'
 import { ProjectMemoryStore } from '../store.js'
 
 const FS_FILE_TOOLS = new Set(['read', 'write', 'edit', 'read_image'])
+const WRITE_TOOLS = new Set(['write', 'edit']) // 编辑/写入 = 高热点
+const READ_TOOLS = new Set(['read', 'read_image'])
 const MAX_FILES_PER_TASK = 100
 const TITLE_MAX = 24
 
@@ -100,7 +102,42 @@ function pickTitle(meta, todos) {
 }
 
 /**
- * 单条会话事件处理（导出便于测试）：user/message 记首条真人文本；
+ * 热点排序：写过(编辑)的文件永远排前；同是写过按 lastWriteAt 倒序；
+ * 纯读文件按 lastReadAt 倒序排在写区之后（任何读取都不会越过写过文件）。
+ */
+export function hotSortFiles(files, meta) {
+  const m = meta || {}
+  return (files || []).slice().sort((a, b) => {
+    const A = m[a]
+    const B = m[b]
+    const aw = A && A.lastWriteAt ? 1 : 0
+    const bw = B && B.lastWriteAt ? 1 : 0
+    if (aw !== bw) return bw - aw
+    if (aw) return String(B.lastWriteAt).localeCompare(String(A.lastWriteAt))
+    return String(B.lastReadAt || '').localeCompare(String(A.lastReadAt || ''))
+  })
+}
+
+/** 触碰文件后更新元数据并重排 task.files（写 vs 读分别记时间/次数）。 */
+export function touchTaskFile(task, rel, kind, now) {
+  task.fileMeta = task.fileMeta || {}
+  if (!task.files.includes(rel)) {
+    task.files.push(rel)
+    if (task.files.length > MAX_FILES_PER_TASK) {
+      const dropped = task.files.shift()
+      delete task.fileMeta[dropped]
+    }
+  }
+  const m = task.fileMeta[rel] || {}
+  m.n = (m.n || 0) + 1
+  if (kind === 'write') m.lastWriteAt = now
+  m.lastReadAt = now
+  task.fileMeta[rel] = m
+  task.files = hotSortFiles(task.files, task.fileMeta)
+}
+
+/**
+ * 单条会话事件处理（导出便于测试）：user/message 记首条真人文本并刷新 lastHumanAt；
  * todo/write → 已绑定则覆盖 steps，未绑定则自动新建任务并绑定；
  * tool/call（fs 工具）→ 绑定任务 files 并集。
  */
@@ -108,17 +145,35 @@ export function onSessionEvent(config, session, event, meta) {
   const sessionId = session?.id
   const type = event?.type
   if (!sessionId || !type) return
+  const now = new Date().toISOString()
 
+  // 人类消息：记首条真人文本 + 若已绑定任务则刷新 lastHumanAt（供“模型自维护不回声任务卡”判断）
   if (type === 'user/message') {
-    if (!meta.has(sessionId) && event.data?.source?.kind === 'user') {
+    if (event.data?.source?.kind === 'user') {
       const text = firstTextOf(event.data?.content)
-      if (text) meta.set(sessionId, { firstHuman: text })
+      const m = meta.get(sessionId) || {}
+      if (!m.firstHuman && text) m.firstHuman = text
+      m.lastHumanAt = now
+      meta.set(sessionId, m)
+      try {
+        const { store } = taskStoreFor(session?.header?.cwd, config)
+        store.commit((s) => {
+          const tid = s.getBoundTaskId(sessionId)
+          const task = tid ? s.getTask(tid) : null
+          if (task && !task.archived) {
+            task.lastHumanAt = now
+            task.updatedAt = now
+            s._dirtyTasks = true
+          }
+        })
+      } catch {
+        /* 人类消息戳记失败不影响主流程 */
+      }
     }
     return
   }
 
   const { root, store } = taskStoreFor(session?.header?.cwd, config)
-  const now = new Date().toISOString()
 
   if (type === 'todo/write') {
     const todos = event.data?.todos
@@ -136,6 +191,7 @@ export function onSessionEvent(config, session, event, meta) {
           title,
           steps: null,
           files: [],
+          fileMeta: {},
           archived: false,
           lastSessionId: sessionId,
           createdAt: now,
@@ -146,6 +202,7 @@ export function onSessionEvent(config, session, event, meta) {
         s.setBinding(sessionId, task.id)
       }
       task.steps = todos
+      task.lastTodoAt = now // 模型/todo 最近一次自维护时刻
       task.updatedAt = now
       task.lastActiveAt = now
       task.lastSessionId = sessionId
@@ -169,13 +226,12 @@ export function onSessionEvent(config, session, event, meta) {
     if (!raw) return
     const rel = normalizeRelFile(root, raw)
     if (!rel) return
+    const kind = WRITE_TOOLS.has(data.name) ? 'write' : READ_TOOLS.has(data.name) ? 'read' : null
+    if (!kind) return
     store.commit((s) => {
       const task = s.getTask(taskId)
       if (!task || task.archived) return
-      if (!task.files.includes(rel)) {
-        task.files.push(rel)
-        if (task.files.length > MAX_FILES_PER_TASK) task.files.shift()
-      }
+      touchTaskFile(task, rel, kind, now)
       task.lastActiveAt = now
       s._dirtyTasks = true
     })

package/src/store.js

@@ -14,6 +14,7 @@ const INSIGHTS_FILE = 'insights.json'
 const SHARDS_DIR = 'shards'
 
 const storeCache = new Map()
+const STORE_CACHE_MAX = 32
 
 function loadJson(filePath, fallback) {
   let raw
@@ -85,6 +86,12 @@ export class ProjectMemoryStore {
     this._loadSharded()
     this._loadInsights()
     storeCache.set(key, this)
+    // 只保留最近打开的项目：长期跨多项目运行时不至于无限增长（被逐出只是下次重新读盘）
+    while (storeCache.size > STORE_CACHE_MAX) {
+      const oldest = storeCache.keys().next().value
+      if (oldest === key) break
+      storeCache.delete(oldest)
+    }
     return this
   }