@yolk_vat-y/dsh-project-memory 0.5.7 → 0.5.9

package/src/commands/task-actions.js

@@ -2,24 +2,22 @@
 //   switch  <taskId>  — 绑定当前会话到该任务（自动解归档），等价 select_task(taskId)
 //   archive <taskId>  — 归档该任务
 // 返回值与 /tasks 同一快照文本（含 JSON 载荷），面板解析后即时刷新，无需再跑一次 /tasks。
-import { memoryRootFor } from '../util/fs.js'
-import { ProjectMemoryStore } from '../store.js'
-import { projectRootFor, adoptStepsToSession, shouldAdoptToHost } from '../setup/taskbridge.js'
+import { taskStoreFor, projectRootFor, NO_PROJECT_ROOT_NOTE, adoptStepsToSession, shouldAdoptToHost } from '../setup/taskbridge.js'
 import { renderTaskSnapshot, buildTaskPayload } from './tasks.js'
 import { fireReflect } from '../reflection-pipeline.js'
 import { resolveRoute } from '../llm-route.js'
 import { fencedJson, invocationContext } from './invocation.js'
+import { stepContent, stepProgress, stepStatus } from '../util/task-view.js'
 
 function describeTask(t) {
-  const done = (t.steps || []).filter((s) => s.status === 'completed').length
-  const total = (t.steps || []).length
+  const { done, total } = stepProgress(t)
   return `「${t.title}」（步骤 ${done}/${total}）`
 }
 
 /**
  * raw 去掉前 n 个空白分隔 token 后的**原始剩余文本**（保留内部空白与引号）。
  * 旧写法 `raw.split(/\s+/).slice(n).join(' ')` 会把标题/JSON 里的连续空格压成一个，
- * `/task rename <id> "a  b"` 于是改名成 "a b"。
+ * `/tasks rename <id> "a  b"` 于是改名成 "a b"。
  */
 function restAfter(raw, n) {
   let i = 0
@@ -43,10 +41,21 @@ function withTaskSnapshot(config, cwd, sid, store, note) {
   return { kind: 'success', text: fencedJson(human, payload) }
 }
 
+/**
+ * 任务动作处理器。
+ *
+ * ⚠️ 这里返回的定义**不再作为宿主命令注册**：合并后唯一的用户命令是 `/tasks`
+ * （见 workflow.js），本处理器是它的子动词分支（`/tasks switch|archive|unbind|rename|todos …`），
+ * 由卡片按钮经 remote.commands.execute 驱动。`name` / `description` / `input` 因此只剩说明意义，
+ * 真正被使用的是 `handler`——它读 `invocation.rawInput` 自行分词，合并前后一字未变。
+ * @param {object} config - 插件配置
+ * @param {object} ctx - 宿主上下文
+ * @returns {{name: string, description: string, input: object, handler: Function}}
+ */
 export function taskCommandDefinition(config, ctx) {
   return {
     name: 'task',
-    description: '任务面板动作：/task switch <任务id> 切换绑定，/task archive <任务id> 归档，/task unbind 取消当前任务绑定',
+    description: '任务面板动作：/tasks switch <任务id> 切换绑定，/tasks archive <任务id> 归档，/tasks unbind 取消当前任务绑定',
     input: { hint: 'switch|archive <任务id> | unbind' },
     handler: (invocation) => {
       try {
@@ -66,8 +75,8 @@ export function taskCommandDefinition(config, ctx) {
         if (!['unbind', 'todos', 'rename'].includes(verb) && (!taskId || rest.length)) {
           return { kind: 'error', text: '[task] 用法: /task switch|archive <任务id> | unbind' }
         }
-        const root = projectRootFor(cwd)
-        const store = new ProjectMemoryStore(memoryRootFor(root, config.memoryDir)).load()
+        const { root, store } = taskStoreFor(cwd, config)
+        if (!store) return { kind: 'error', text: NO_PROJECT_ROOT_NOTE }
 
         if (verb === 'unbind') {
           if (sid) store.removeBinding(sid)
@@ -116,11 +125,7 @@ export function taskCommandDefinition(config, ctx) {
             return { kind: 'error', text: '[task] todos 需要 JSON 数组参数（由面板自动生成）' }
           }
           const norm = todos
-            .map((s) => {
-              const content = String(s?.content ?? s?.text ?? '').trim()
-              const status = ['pending', 'in_progress', 'completed'].includes(s?.status) ? s.status : 'pending'
-              return { content, status }
-            })
+            .map((s) => ({ content: String(stepContent(s)).trim(), status: stepStatus(s) }))
             .filter((s) => s.content.length > 0)
           const boundId = sid ? store.getBoundTaskId(sid) : null
           if (!boundId) {

package/src/commands/tasks.js

@@ -3,27 +3,9 @@
 // renderTaskSnapshot / buildTaskPayload 导出供 task-actions.js 复用（面板动作后返回同一快照）。
 import { memoryRootFor } from '../util/fs.js'
 import { ProjectMemoryStore } from '../store.js'
-import { projectRootFor } from '../setup/taskbridge.js'
+import { NO_PROJECT_ROOT_NOTE, projectRootFor } from '../setup/taskbridge.js'
 import { fencedJson, invocationContext } from './invocation.js'
-
-function timeAgo(iso) {
-  const diff = Date.now() - new Date(iso).getTime()
-  const m = Math.floor(diff / 60000)
-  if (m < 1) return '刚刚'
-  if (m < 60) return `${m}分钟前`
-  const h = Math.floor(m / 60)
-  if (h < 24) return `${h}小时前`
-  return `${Math.floor(h / 24)}天前`
-}
-
-/** 步骤在历史数据里可能是字符串，也可能是 {content|text, status}：统一取文本与状态。 */
-function stepContent(s) {
-  if (typeof s === 'string') return s
-  return s?.content ?? s?.text ?? ''
-}
-function stepStatus(s) {
-  return typeof s === 'string' ? 'pending' : (s?.status || 'pending')
-}
+import { stepContent, stepProgress, stepStatus, timeAgo } from '../util/task-view.js'
 
 export function buildTaskPayload(tasks, boundId, archived) {
   return JSON.stringify({
@@ -48,6 +30,7 @@ export function buildTaskPayload(tasks, boundId, archived) {
  */
 export function renderTaskSnapshot(config, cwd, sid) {
   const root = projectRootFor(cwd)
+  if (!root) return { kind: 'error', text: NO_PROJECT_ROOT_NOTE }
   const store = new ProjectMemoryStore(memoryRootFor(root, config.memoryDir)).load()
   const tasks = store.getTasks()
   const active = tasks.filter((t) => !t.archived)
@@ -62,8 +45,7 @@ export function renderTaskSnapshot(config, cwd, sid) {
   }
   const lines = [`项目 ${root}`, `任务: ${active.length} 套${archived ? `（归档 ${archived}）` : ''}`, '']
   for (const t of active) {
-    const done = (t.steps || []).filter((s) => stepStatus(s) === 'completed').length
-    const total = (t.steps || []).length
+    const { done, total } = stepProgress(t)
     const progress = total ? `${done}/${total}` : '无步骤'
     const inProgress = (t.steps || []).find((s) => stepStatus(s) === 'in_progress')
     const step = inProgress ? ` · 当前: ${stepContent(inProgress)}` : ''

package/src/commands/workflow.js

@@ -0,0 +1,54 @@
+/**
+ * 单一用户命令 `/tasks`：把合并前的三条宿主命令（`/tasks`、`/task`、`/insight`）收成一条，
+ * 其余动作作为「子动词」由面板按钮经 `remote.commands.execute` 直接驱动。
+ *
+ * 为什么合并：宿主命令**只要注册就会出现在 `/` 菜单的「指令」组里** —— `commands.list()`
+ * 与 `commands.execute()` 读同一个视图，`CommandDefinition` 也没有 hidden 字段，插件无法隐藏
+ * 自己的宿主命令（见 client/slash.ts 的长注释）。三条命令 = 三行去不掉的原始行；而用户可见
+ * 入口已经收进自建的「工作流」组，于是同一批能力在菜单里出现两遍。合并后只剩一行。
+ *
+ * 为什么**不**声明 `input`：声明了就是 leadingInput —— 手敲 `/tasks` 回车时，
+ * `ui-commands.matchEnter` 对带 input 的命令一律返回 claim（回填 `/tasks ` 并要求再按一次
+ * 回车）。不声明时裸 `/tasks` 回车立刻执行，与合并前完全一致。
+ * 代价：手敲 `/tasks switch x` 这类带参数的行不再被认作命令（会作为普通消息发给模型）。
+ * 这些动作的入口本来就是面板按钮，不需要用户手敲。
+ *
+ * 子动词约定：
+ *   /tasks                                   → 任务清单快照（等价于合并前的 /tasks）
+ *   /tasks switch|archive|unbind|rename|todos …  → 任务动作（等价于 /task …）
+ *   /tasks insight list|confirm|promote|… …      → 记忆动作（等价于 /insight …）
+ */
+import { tasksCommandDefinition } from './tasks.js'
+import { taskCommandDefinition } from './task-actions.js'
+import { insightCommandDefinition } from './insight-actions.js'
+
+/** 记忆动作的分派前缀；也是 `/tasks` 之后第一个 token。 */
+const INSIGHT_VERB = 'insight'
+
+/**
+ * 造出唯一的用户命令定义。
+ * @param {object} config - 插件配置
+ * @param {object} ctx - 宿主上下文
+ * @returns {{name: string, description: string, handler: Function}}
+ */
+export function workflowCommandDefinition(config, ctx) {
+  const snapshot = tasksCommandDefinition(config, ctx)
+  const taskAction = taskCommandDefinition(config, ctx)
+  const insightAction = insightCommandDefinition(config, ctx)
+  return {
+    name: 'tasks',
+    description: '工作流面板：任务清单与项目经验（切换/归档/审核等动作由面板按钮驱动）',
+    handler: (invocation) => {
+      const raw = (invocation?.rawInput || '').trim()
+      const verb = raw === '' ? '' : raw.split(/\s+/)[0]
+      // 裸 /tasks：任务清单快照（保持合并前的行为与文案）
+      if (verb === '') return snapshot.handler(invocation)
+      // /tasks insight …：把前缀剥掉后原样交给记忆动作处理器（它自己 trim + 分词）
+      if (verb === INSIGHT_VERB) {
+        return insightAction.handler({ ...invocation, rawInput: raw.slice(INSIGHT_VERB.length) })
+      }
+      // 其余一律当任务动作（switch / archive / unbind / rename / todos）
+      return taskAction.handler(invocation)
+    },
+  }
+}

package/src/index.js

@@ -1,4 +1,5 @@
 import Schema from '@deepseek-ai/schemastery'
+import { DEFAULT_SCAN_DEPTH, DEFAULT_SCAN_FILES, isUnsafeRoot } from './util/fs.js'
 import { indexDocTool } from './tools/index-doc.js'
 import { indexRepoTool, indexRepository } from './tools/index-repo.js'
 import { queryMemoryTool } from './tools/query-memory.js'
@@ -14,9 +15,7 @@ import { listTasksTool, selectTaskTool, archiveTaskTool, showTaskPanelTool } fro
 import { lessonTool } from './tools/lesson-tools.js'
 import { installAutoInject } from './auto-inject.js'
 import { rememberRoute } from './llm-route.js'
-import { tasksCommandDefinition } from './commands/tasks.js'
-import { taskCommandDefinition } from './commands/task-actions.js'
-import { insightCommandDefinition } from './commands/insight-actions.js'
+import { workflowCommandDefinition } from './commands/workflow.js'
 
 export const name = 'dsh-project-memory'
 export const inject = ['llm', 'tools']
@@ -42,6 +41,15 @@ export const Config = Schema.object({
   autoIndexOnFirstUse: Schema.boolean().default(false),
   watch: Schema.boolean().default(true),
   watchInterval: Schema.number().default(15),
+  // 危险根护栏（issue #5）：家目录 / 文件系统根 / 系统目录 / 包管理器前缀（/opt/homebrew …）
+  // 整体扫描会吃满内存，默认一律拒绝。**自动路径永不越权**——懒索引、会话审计、任务桥在
+  // 这类目录里始终零副作用；这个开关只放开**显式**工具调用（index_repo / watch_repo /
+  // remember 等带 root 的调用）。
+  allowUnsafeRoots: Schema.boolean().default(false),
+  // 单次扫描上限。超过即截断（并跳过"删除本轮未见到条目"的清理，避免把没扫到的文件误删）。
+  // 显式设 0 表示不限制——自担风险。
+  maxScanFiles: Schema.number().default(DEFAULT_SCAN_FILES),
+  maxScanDepth: Schema.number().default(DEFAULT_SCAN_DEPTH),
   tsPath: Schema.string(),
   enableTypeScript: Schema.boolean().default(true),
   tasklist: Schema.object({
@@ -77,6 +85,9 @@ export const Config = Schema.object({
     signalMinRatio: Schema.number().default(0.5),
     // resident 任务卡最多显示几个「编辑中」文件
     editedMax: Schema.number().default(3),
+    // 记忆根是"推定"的（会话工作目录，且该目录没有项目标记）时，首次注入前通告模型
+    // 根在哪、怎么改。状态声明，只发一次、不占条目额度。
+    rootNotice: Schema.boolean().default(true),
     // 模型自己维护清单且之后没有新人类消息时，不把任务卡回声给模型
     skipEchoSelfTodo: Schema.boolean().default(true),
     // ⚠️ 旧兼容闸门，**刻意不给默认值**：cfgEngine 以「relevanceMin 是否为 number」选分支，
@@ -90,6 +101,24 @@ export const Config = Schema.object({
     // 同一条 insight 在本会话里重复注入的冷却（pre-step 步数）。0（默认）= 正文没变就不再注入：
     // 注入消息留在会话历史里（宿主只追加不压缩），整块重发只是重复占位。>0 用于外部裁剪历史的场景。
     reinjectItemsAfter: Schema.number().default(0),
+    // --- 准入旋钮（0.5.8 起补声明）---
+    // 下面这些键自 S2/S4 起就在 cfgEngine / cfgAudit 里生效、README 也一直写着，但**从未**在
+    // Schema 里声明过：走 cordis.patch.yml 配它们会被宿主按「not a declared property」拒掉，
+    // 等于文档里的旋钮是假的。默认值以 cfgEngine 的兜底值为准（那里是权威，这里只负责暴露）。
+    gateCooldownSteps: Schema.number().default(2),
+    maxItemsPerSession: Schema.number().default(12),
+    maxItemCharsPerSession: Schema.number().default(4000),
+    hintMinCoverage: Schema.number().default(0.45),
+    hintMinMatched: Schema.number().default(2),
+    hintMinSupport: Schema.number().default(0.15),
+    legacyScope: Schema.union(['filter', 'ignore']).default('filter'),
+    auditLog: Schema.boolean().default(true),
+    auditMaxBytes: Schema.number().default(262144),
+    // 影子记录（admission-shadow.jsonl）：**每步**一行，含全部候选的判据特征与场景。
+    // 主审计只在真的注入时写，静默步零痕迹 → 无法离线重放"换个阈值会怎样"，也攒不出样本。
+    // 只写盘、不进 prompt、不花 token，所以默认开。
+    shadowLog: Schema.boolean().default(true),
+    shadowMaxBytes: Schema.number().default(2097152),
   }).default({}),
 })
 
@@ -123,15 +152,15 @@ export function apply(ctx, config) {
   ctx.tools.register(archiveTaskTool(config, { llm: ctx.llm, ctx }))
   ctx.tools.register(showTaskPanelTool(config))
 
-  // /tasks、/task、/insight 用户命令（宿主 commands 服务存在时注册，feature-detect 降级）
+  // /tasks：唯一的用户命令（合并自原 /tasks、/task、/insight —— 宿主命令只要注册就会
+  // 出现在 `/` 菜单的「指令」组里且无法隐藏，三条命令就是三行去不掉的原始行）。
+  // 切换/归档/审核等动作作为子动词，由面板按钮经 remote.commands.execute 驱动。
   try {
     ctx.inject(['commands'], (commandsCtx) => {
-      commandsCtx.commands.register(tasksCommandDefinition(config, ctx))
-      commandsCtx.commands.register(taskCommandDefinition(config, ctx))
-      commandsCtx.commands.register(insightCommandDefinition(config, ctx))
+      commandsCtx.commands.register(workflowCommandDefinition(config, ctx))
     })
   } catch (err) {
-    console.error(`[dsh-project-memory] /tasks,/task,/insight registration skipped: ${err.message}`)
+    console.error(`[dsh-project-memory] /tasks registration skipped: ${err.message}`)
   }
 
   ctx.tools.register(indexDocTool(ctx, config))
@@ -153,9 +182,22 @@ export function apply(ctx, config) {
       let cancelled = false
       const run = async () => {
         const root = process.cwd()
+        // 全量索引 cwd 是显式开启的行为，但"cwd 是家目录"几乎总是误用：拒绝并说明，
+        // 而不是替用户把整棵树扫一遍（旧实现直接 indexRepository(ctx, config, cwd)，
+        // 没有任何护栏——这正是 issue #5 里最直接的 OOM 入口）。
+        if (isUnsafeRoot(root) && config.allowUnsafeRoots !== true) {
+          if (!cancelled) {
+            console.error(
+              `[dsh-project-memory] autoIndexOnFirstUse skipped: cwd ${root} is not a project root ` +
+                '(home / system / package-manager prefix). Start dsh inside a project directory, ' +
+                'or set allowUnsafeRoots: true to override.',
+            )
+          }
+          return
+        }
         try {
           watchManager.addRoot(root)
-          const report = await indexRepository(ctx, config, root)
+          const report = await indexRepository(ctx, config, root, { allowUnsafe: config.allowUnsafeRoots === true })
           if (!cancelled) console.log(`[dsh-project-memory] ${report}`)
         } catch (err) {
           if (!cancelled) console.error(`[dsh-project-memory] auto-index failed for ${root}: ${err.message}`)

package/src/insight-store.js

@@ -180,6 +180,45 @@ export function mergeInto(existing, base, cfg, nowIso) {
   return existing
 }
 
+/**
+ * 使用记账：条目被**真正用到**时更新活跃度——注入进了上下文，或被 `query_memory` 命中。
+ *
+ * 为什么必须有：`applyDecay` / `pruneItems` 判活跃度只看 `lastHitAt || updatedAt || createdAt`，
+ * 而 `lastHitAt` 此前只由 merge/reinforce 写（= 模型又写了一条相近的知识）。于是一条天天被注入、
+ * 但从没人重写它的教训，`decayDays`（默认 90）之后会被自动归档、再也不会被推送——**用得最多的
+ * 反而等于没人用过**。这是行为缺陷，不是调优问题。
+ *
+ * 记账**不参与任何注入判据**：它只影响活跃度/衰减，以及离线训练样本的标签。
+ * 语义是"曝光次数"而非"被采纳次数"——更强的信号（模型是否真的照着做了）需要另外的回路。
+ * 只记非归档条目（归档件本来就召回不到）。返回实际加一的条数，调用方据此决定是否落盘。
+ * @returns {number} 被加一的条目数
+ */
+export function recordHit({ store, globalStore, ids, nowIso } = {}) {
+  const want = new Set((ids || []).filter(Boolean))
+  if (!want.size) return 0
+  const now = nowIso || new Date().toISOString()
+  let n = 0
+  const touch = (items) => {
+    let c = 0
+    for (const it of items || []) {
+      if (!it || it.archived || !want.has(it.id)) continue
+      it.hitCount = num(it.hitCount, 0) + 1
+      it.lastHitAt = now
+      c++
+    }
+    n += c
+    return c
+  }
+  if (store && typeof store.insightItems === 'function') {
+    const items = store.insightItems()
+    if (touch(items)) store.replaceInsightItems(items) // 标脏；落盘由调用方决定
+  }
+  if (globalStore && typeof globalStore.items === 'function') {
+    if (touch(globalStore.items())) globalStore.markDirty()
+  }
+  return n
+}
+
 export function reinforceOnly(existing, base, nowIso) {
   const now = nowIso || new Date().toISOString()
   existing.sourceTaskIds = unionStrings(existing.sourceTaskIds, base.sourceTaskIds)

package/src/lazy.js

@@ -1,84 +1,21 @@
 import path from 'node:path'
-import { tmpdir } from 'node:os'
-import { existsSync, readdirSync, statSync } from 'node:fs'
-import { memoryRootFor, relativePath, storeKey } from './util/fs.js'
+import { statSync } from 'node:fs'
+import { findProjectRoot, isUnsafeRoot, memoryRootFor, relativePath, storeKey } from './util/fs.js'
 import { DROP, OVERSIZE, UNCHANGED, commitFileUpdates, fileKind, planFileIndex, toFileUpdate } from './index-pipeline.js'
 import { ProjectMemoryStore } from './store.js'
 import { onFileObserved } from './enhancer.js'
 
-const STRONG_MARKERS = ['.git', '.hg', '.svn']
+// 根推导策略已收敛到 util/fs.js（唯一实现）。这里重新导出，保持既有 import 路径可用。
+export { findProjectRoot }
 
-const WEAK_MARKERS = [
-  '.dsh-project-memory',
-  'package.json',
-  'go.mod',
-  'Cargo.toml',
-  'pyproject.toml',
-  'requirements.txt',
-  'pom.xml',
-]
-
-const SOURCE_DIR_NAMES = new Set([
-  'src', 'app', 'lib', 'libs', 'tools', 'include', 'core', 'modules',
-  'scripts', 'components', 'assets', 'utils', 'shared', 'common', 'server', 'client',
-])
-
-function looksLikeProjectRoot(dir) {
-  let hasReadmeFile = false
-  let sourceDirs = 0
-  try {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const name = entry.name.toLowerCase()
-      if (entry.isDirectory()) {
-        if (SOURCE_DIR_NAMES.has(name)) sourceDirs++
-      } else if (name.startsWith('readme')) {
-        hasReadmeFile = true
-      }
-    }
-  } catch {
-    return false
-  }
-  return sourceDirs >= 2 || (hasReadmeFile && sourceDirs >= 1)
-}
-
-function sameDir(a, b) {
-  return storeKey(path.resolve(a)) === storeKey(path.resolve(b))
-}
-
-export function findProjectRoot(filePath, ceiling = path.resolve(tmpdir())) {
-  let dir = path.dirname(filePath)
-  for (;;) {
-    if (!sameDir(dir, ceiling)) {
-      for (const marker of STRONG_MARKERS) {
-        if (existsSync(path.join(dir, marker))) return dir
-      }
-    }
-    const parent = path.dirname(dir)
-    if (parent === dir || sameDir(parent, ceiling)) break
-    dir = parent
-  }
-
-  dir = path.dirname(filePath)
-  let best = null
-  for (;;) {
-    if (!sameDir(dir, ceiling)) {
-      for (const marker of WEAK_MARKERS) {
-        if (existsSync(path.join(dir, marker))) return dir
-      }
-      if (!best && looksLikeProjectRoot(dir)) best = dir
-    }
-    const parent = path.dirname(dir)
-    if (parent === dir || sameDir(parent, ceiling)) break
-    dir = parent
-  }
-  return best || path.dirname(filePath)
-}
-
-export async function indexFile(ctx, config, filePath, watchManager = null) {
+export async function indexFile(ctx, config, filePath, watchManager = null, sessionRoot = null) {
   const kind = fileKind(path.extname(filePath).toLowerCase())
   if (!kind) return false
-  const root = findProjectRoot(filePath)
-  if (!root) return false
+  // 根来源优先级：显式 watch 过的根 → 项目标记 → 会话工作目录（安全时）。
+  // 显式登记过的根优先，是为了让"没有标记但被 watch_repo 指定过"的项目也能持续刷新。
+  const extraRoots = watchManager ? [...watchManager.roots.keys()] : []
+  const root = findProjectRoot(filePath, { extraRoots, sessionRoot })
+  if (!root || isUnsafeRoot(root)) return false
 
   const memoryDir = memoryRootFor(root, config.memoryDir)
   const store = new ProjectMemoryStore(memoryDir).load()
@@ -95,8 +32,9 @@ export async function indexFile(ctx, config, filePath, watchManager = null) {
   }
   if (plan.key === UNCHANGED || plan.key === OVERSIZE) return false
 
-  if (watchManager) {
-    watchManager.addRoot(root)
+  if (watchManager && watchManager.addRoot(root)) {
+    // 只有真正新登记的根才持久化：addRoot 拒绝的根（不安全/不存在）不再被无条件
+    // addWatch 记进 watch.json —— 那样会造出一个每次启动都复活的"僵尸根"。
     store.addWatch(root)
   }
 
@@ -122,28 +60,32 @@ export function setupLazyIndexing(ctx, config, watchManager = null) {
   const flush = async () => {
     timer = null
     const batch = codeFirst([...pending.keys()])
+    const roots = new Map(pending)
     pending.clear()
     for (const filePath of batch) {
       try {
-        await indexFile(ctx, config, filePath, watchManager)
+        await indexFile(ctx, config, filePath, watchManager, roots.get(filePath) || null)
       } catch (err) {
         console.error(`[dsh-project-memory] lazy index failed for ${filePath}: ${err.message}`)
       }
     }
   }
 
-  const queue = (filePath) => {
-    pending.set(filePath, true)
+  const queue = (filePath, sessionRoot) => {
+    pending.set(filePath, sessionRoot || null)
     if (!timer) {
       timer = setTimeout(flush, 300)
       if (timer.unref) timer.unref()
     }
   }
 
-  ctx.on('fs/observed', (target, observation) => {
+  // 第三个参数是宿主工具执行上下文（tool-fs / str-replace-editor 都以 `exec` 发射），
+  // 取它的 `agent.session.header.cwd` 作为**本次读取所在会话**的工作目录——比
+  // process.cwd() 精确（web profile 下同一进程可能有多个会话/项目）。
+  ctx.on('fs/observed', (target, observation, actor) => {
     if (!target || !observation || observation.kind !== 'present') return
     if (typeof target.displayPath !== 'string' || !target.displayPath) return
-    queue(target.displayPath)
+    queue(target.displayPath, actor?.agent?.session?.header?.cwd)
   })
 
   ctx.effect(() => () => {

package/src/reflection-pipeline.js

@@ -11,6 +11,7 @@ import { memoryRootFor } from './util/fs.js'
 import { cfgInsight, saveInsight, GlobalStore, defaultGlobalFile } from './insight-store.js'
 import { chatText, parseStructuredJson } from './llm.js'
 import { noteDegraded } from './llm-route.js'
+import { stepContent } from './util/task-view.js'
 
 export const REFLECT_SYSTEM =
   'You distill task work into durable lessons and decisions for project memory. ' +
@@ -23,7 +24,7 @@ export const REFLECT_SYSTEM =
 export function taskReflectionSnapshot(task) {
   return {
     title: task ? task.title : '',
-    steps: ((task && task.steps) || []).map((s) => (typeof s === 'string' ? s : s.content || s.text || '')).filter(Boolean).join('\n'),
+    steps: ((task && task.steps) || []).map((s) => stepContent(s)).filter(Boolean).join('\n'),
     files: ((task && task.files) || []).join('\n'),
   }
 }

package/src/setup/taskbridge.js

@@ -3,9 +3,9 @@
 // tool/call data.arguments 为 JSON 字符串；fs 工具名 read/write/edit/read_image，参数 file_path。
 import path from 'node:path'
 import { createHash, randomUUID } from 'node:crypto'
-import { memoryRootFor } from '../util/fs.js'
-import { findProjectRoot } from '../lazy.js'
+import { memoryRootFor, resolveProjectMemoryRoot } from '../util/fs.js'
 import { ProjectMemoryStore } from '../store.js'
+import { stepContent, stepStatus } from '../util/task-view.js'
 
 const FS_FILE_TOOLS = new Set(['read', 'write', 'edit', 'read_image'])
 const WRITE_TOOLS = new Set(['write', 'edit']) // 编辑/写入 = 高热点
@@ -32,14 +32,24 @@ export function genTaskId(projectRoot, title) {
   return `tsk_${hash8(projectRoot)}_${slug}_${Date.now().toString(36)}_${randomUUID().slice(0, 6)}`
 }
 
-/** 项目根推导：findProjectRoot 期望文件路径，传目录会从父级起跳，故用目录内探针路径。 */
+/** 会话根不可用时统一的用户提示（/tasks、/task、/insight 共用）。 */
+export const NO_PROJECT_ROOT_NOTE =
+  '当前工作目录不是项目根（是家目录/系统目录且没有项目标记），项目记忆与任务清单已停用；请在项目目录内启动 dsh。'
+
+/**
+ * 项目根推导：与全插件同一套策略（util/fs.js 的 `resolveProjectMemoryRoot`）——
+ * 最近的 VCS/清单标记优先；标记缺失但 cwd 本身是安全目录时退回 cwd（任务清单按
+ * "会话工作目录"归属，没有标记的普通目录也要能用）；cwd 是家目录/系统/包管理器前缀
+ * 且上方没有标记时返回 null。
+ */
 export function projectRootFor(cwd) {
-  const base = cwd || process.cwd()
-  return findProjectRoot(path.join(base, '__taskbridge__.probe'))
+  return resolveProjectMemoryRoot(cwd || process.cwd())
 }
 
+/** 没有可用项目根时返回 `{ root: null, store: null }`，调用方据此整段跳过。 */
 export function taskStoreFor(cwd, config) {
   const root = projectRootFor(cwd)
+  if (!root) return { root: null, store: null }
   return { root, store: new ProjectMemoryStore(memoryRootFor(root, config.memoryDir)).load() }
 }
 
@@ -63,8 +73,6 @@ export function firstTextOf(content) {
   return ''
 }
 
-const TODO_STATUSES = new Set(['pending', 'in_progress', 'completed'])
-
 /**
  * 反向接管：任务成为某会话绑定后，把任务步骤推成宿主 todo/write 快照，
  * 让 dsh 渲染的任务清单（UI/投影）变成我们这套任务的步骤。
@@ -75,11 +83,7 @@ export function adoptStepsToSession(session, task) {
   if (!session || typeof session.append !== 'function') return false
   const steps = Array.isArray(task?.steps) ? task.steps : null
   if (!steps || steps.length === 0) return false
-  const todos = steps.map((s) => {
-    const raw = typeof s === 'string' ? s : s?.content ?? s?.text ?? ''
-    const status = TODO_STATUSES.has(s?.status) ? s.status : 'pending'
-    return { content: String(raw), status }
-  })
+  const todos = steps.map((s) => ({ content: String(stepContent(s)), status: stepStatus(s) }))
   session.append('todo/write', { todos })
   return true
 }
@@ -182,6 +186,7 @@ export function onSessionEvent(config, session, event, meta) {
       meta.set(sessionId, m)
       try {
         const { store } = taskStoreFor(session?.header?.cwd, config)
+        if (!store) return
         store.commit((s) => {
           const tid = s.getBoundTaskId(sessionId)
           const task = tid ? s.getTask(tid) : null
@@ -199,6 +204,8 @@ export function onSessionEvent(config, session, event, meta) {
   }
 
   const { root, store } = taskStoreFor(session?.header?.cwd, config)
+  // 没有项目根（家目录/系统目录会话）：不建档、不记文件、不落任何盘。
+  if (!store) return
 
   if (type === 'todo/write') {
     const todos = event.data?.todos

package/src/tools/forget.js

@@ -1,5 +1,5 @@
 import { defineTool } from '@deepseek-ai/dsh-tools'
-import { assertIndexRoot, memoryRootFor, resolveIndexRoot } from '../util/fs.js'
+import { assertIndexRoot, memoryRootFor, resolveSafeIndexRoot } from '../util/fs.js'
 import { ProjectMemoryStore } from '../store.js'
 
 export function forgetTool(config) {
@@ -23,7 +23,7 @@ export function forgetTool(config) {
       render: (_args, value) => [{ type: 'text', text: value }],
     },
     async execute(args, exec) {
-      const root = resolveIndexRoot(exec, args.root)
+      const root = resolveSafeIndexRoot(exec, args.root, config)
       assertIndexRoot(root, args.root || root)
       const memoryDir = memoryRootFor(root, config.memoryDir)
       const store = new ProjectMemoryStore(memoryDir).load()

package/src/tools/index-doc.js

@@ -1,11 +1,10 @@
 import { defineTool } from '@deepseek-ai/dsh-tools'
 import path from 'node:path'
-import { assertReadableFile, memoryRootFor, sha256OfFile, storeKey } from '../util/fs.js'
+import { assertIndexRoot, assertReadableFile, assertSafeRoot, findProjectRoot, memoryRootFor, sessionMemoryRootOrNull, sha256OfFile, storeKey } from '../util/fs.js'
 import { buildDocEntries } from '../doc-pipeline.js'
 import { docEntriesNeedBackfill } from '../doc-index.js'
 import { linkEntries } from '../link.js'
 import { ProjectMemoryStore } from '../store.js'
-import { findProjectRoot } from '../lazy.js'
 
 export function indexDocTool(ctx, config) {
   return defineTool({
@@ -22,16 +21,32 @@ export function indexDocTool(ctx, config) {
       },
       root: {
         type: 'string',
-        description: 'Project root where the .dsh-project-memory store lives. Defaults to the file\'s directory.',
+        description: 'Project root where the .dsh-project-memory store lives. Defaults to the session\'s project root.',
       },
     },
     output: {
       schema: { type: 'string' },
       render: (_args, value) => [{ type: 'text', text: value }],
     },
-    async execute(args) {
+    async execute(args, exec) {
       const filePath = assertReadableFile(args.file_path, config.maxFileSizeMb)
-      const root = path.resolve(args.root && args.root.trim() ? args.root : findProjectRoot(filePath))
+      const explicit = args.root && args.root.trim() ? args.root : null
+      let root
+      if (explicit) {
+        root = path.resolve(explicit)
+        assertIndexRoot(root, explicit)
+        assertSafeRoot(root, { requested: explicit, allowUnsafe: config?.allowUnsafeRoots === true })
+      } else {
+        // 与懒索引同序：文件自身的项目标记优先，其次才是会话记忆根（安全但无标记的 cwd）。
+        const sessionRoot = sessionMemoryRootOrNull(exec, config)
+        root = findProjectRoot(filePath, { sessionRoot })
+        if (!root) {
+          return (
+            `Not indexed: ${filePath} is not inside a detected project ` +
+            '(no .git / package.json / pyproject.toml … marker above it). Pass root explicitly to place the memory store.'
+          )
+        }
+      }
       const memoryDir = memoryRootFor(root, config.memoryDir)
 
       const store = new ProjectMemoryStore(memoryDir).load()