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

package/src/auto-inject.js

@@ -8,7 +8,9 @@
 import { createHash } from 'node:crypto'
 import { createUserMessage } from '@deepseek-ai/dsh-llm'
 import { ProjectMemoryStore } from './store.js'
-import { memoryRootFor } from './util/fs.js'
+import { hasProjectMarker, isUnsafeRoot, memoryRootFor, resolveProjectMemoryRoot } from './util/fs.js'
+import { textOf } from './util/text.js'
+import { stepContent } from './util/task-view.js'
 import { insightMatchText, normalizedTokenOverlap } from './similarity.js'
 import { BoundedMap, SessionCache } from './util/session-cache.js'
 import { cfgInsight, GlobalStore, defaultGlobalFile, recordHit } from './insight-store.js'
@@ -113,14 +115,6 @@ export function cfgEngine(config) {
   }
 }
 
-function textOf(message) {
-  const blocks = (message && message.content) || []
-  return blocks
-    .filter((b) => b && b.type === 'text' && typeof b.text === 'string')
-    .map((b) => b.text)
-    .join('\n')
-}
-
 export function lastUserText(messages) {
   if (!Array.isArray(messages)) return ''
   let fallback = ''
@@ -181,7 +175,7 @@ export function shouldEchoTaskCard(task, cfg) {
 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 steps = (task.steps || []).map((s) => stepContent(s).slice(0, 80))
   const progress = steps.length ? `${steps.length} 步` : ''
   const card = [
     `任务: ${task.title || '(untitled)'}`,
@@ -472,6 +466,8 @@ class InjectionSessions {
     // 反应窗口：本会话最近观察到的 tool/call（参数里有 git commit / npm publish / 改动的路径）。
     // 宿主没有"工具执行前拦截"钩子，所以这是 pre-step 之外唯一能拿到的动作事实。
     this.observed = cache(() => [])
+    // 本会话是否已通告"记忆根是推定的"（会话工作目录，无项目标记）。状态声明只发一次。
+    this.rootNoticed = cache(() => false)
     this._all = Object.values(this)
   }
 
@@ -532,15 +528,38 @@ export function installAutoInject(ctx, config) {
   })
 }
 
+/** 已就「会话根不安全」提示过的目录：每个进程、每个根只提示一次。 */
+const warnedUnsafeRoots = new Set()
+
+function warnUnsafeSessionRoot(root) {
+  if (warnedUnsafeRoots.has(root)) return
+  warnedUnsafeRoots.add(root)
+  console.error(
+    `[dsh-project-memory] session cwd ${root} is not a project root (home / system / package-manager prefix); ` +
+      'project memory and its audit logs are disabled for this session. Start dsh inside a project directory to enable them.',
+  )
+}
+
 /**
  * 一个 pre-step 的注入决策：解析会话 → 排程 → 必要时构造消息。
  * 返回 null 表示本步无事可做（交回原决策）。
  */
 async function injectForStep({ payload, decision, config, cfg, audit, shadow, sessions }) {
   const session = payload && payload.agent && payload.agent.session
-  const root = session && session.header && session.header.cwd
+  const cwd = session && session.header && session.header.cwd
   const sessionId = session && session.id
-  if (!root || !sessionId) return null
+  if (!cwd || !sessionId) return null
+  // 会话 cwd 是家目录/系统目录时整条链路停在这里：不读 store（历史遗留的超大 store
+  // 光是 load() 就能 OOM），也不写审计——`appendShadowAudit` 里的 mkdirSync 正是把
+  // `.dsh-project-memory` 造进家目录、进而触发"目录自标记 → 家目录被锁成项目"的那一步。
+  if (isUnsafeRoot(cwd)) {
+    warnUnsafeSessionRoot(cwd)
+    return null
+  }
+  // 记忆根与懒索引/工具侧同一套解析：项目标记优先，其次是安全的会话工作目录。
+  // 少了这一步，同一个会话的审计日志与懒索引会落在两个不同的 store 里。
+  const root = resolveProjectMemoryRoot(cwd)
+  if (!root) return null
 
   const query = lastUserText(decision.messages)
   const memoryRoot = memoryRootFor(root, config.memoryDir)
@@ -602,8 +621,14 @@ async function injectForStep({ payload, decision, config, cfg, audit, shadow, se
     silence: silence.reason,
   }), shadow)
 
-  const fp = fingerprint(built.dedupeText ?? built.text)
-  if (!built.text || fp === sessions.lastText.peek(sessionId)) return null
+  // 记忆根通告：根是**推定**的（会话工作目录，且该目录没有任何项目标记）时，
+  // 第一次注入前告诉模型"记忆现在存在哪、怎么改"。它是状态声明（与常驻任务卡同类），
+  // 只发一次、不占条目额度；否则模型只看到一条来自某处的记忆，却不知道那个根是怎么来的。
+  const notice = rootNotice({ root, sessionId, sessions, config })
+
+  const fp = built.text ? fingerprint(built.dedupeText ?? built.text) : fingerprint(notice || '')
+  const injectedText = notice ? (built.text ? `${notice}\n${built.text}` : notice) : built.text
+  if (!injectedText || fp === sessions.lastText.peek(sessionId)) return null
   sessions.lastText.set(sessionId, fp)
 
   // 只记真的进了上下文的那几条：dropped 的没被看到，不能记账（否则以后永远不再注入）。
@@ -636,7 +661,7 @@ async function injectForStep({ payload, decision, config, cfg, audit, shadow, se
     sessionId,
     root,
     step: stepNo,
-    text: built.text,
+    text: injectedText,
     labels: built.labels,
     reasons: built.reasons,
     dropped: built.dropped,
@@ -644,7 +669,29 @@ async function injectForStep({ payload, decision, config, cfg, audit, shadow, se
     silence: silence.reason,
   }), audit)
 
-  return { ...decision, messages: [...decision.messages, injectionMessage(built.text)] }
+  return { ...decision, messages: [...decision.messages, injectionMessage(injectedText)] }
+}
+
+/**
+ * 「记忆根是推定的」一次性通告。
+ *
+ * 触发条件：根是**安全目录但自身没有任何项目标记**（即根来自会话工作目录，而不是
+ * `.git`/`package.json` 这类声明）。此时插件会按 cwd 建 `.dsh-project-memory`——必须
+ * 让模型知道这件事，否则它只会看到记忆来自一个自己没指定过的位置，而纠正的成本随
+ * 会话推进快速上升。通告只发一次，且与常驻任务卡同类：是状态声明，不占条目额度。
+ *
+ * 关掉它：`autoContext.rootNotice: false`。
+ */
+function rootNotice({ root, sessionId, sessions, config }) {
+  if (config?.autoContext?.rootNotice === false) return null
+  if (sessions.rootNoticed.peek(sessionId)) return null
+  if (hasProjectMarker(root)) return null
+  sessions.rootNoticed.set(sessionId, true)
+  return (
+    `memory root: ${root} (inferred from the session working directory; no project marker found). ` +
+    'If project memory should live elsewhere, pass `root: <dir>` to index_repo / watch_repo / remember / query_memory, ' +
+    'or restart dsh inside the project directory.'
+  )
 }
 
 /**

package/src/client/TaskPanel.tsx

@@ -113,7 +113,7 @@ function TaskPanelView({ ctx }: { ctx: any }) {
     try {
       response = await commands.execute(sessionId, line, [])
     } catch (err) {
-      setSyncError(String(err?.message ?? err))
+      setSyncError(String((err as { message?: unknown } | null | undefined)?.message ?? err))
       return false
     }
     const envelope = response as { ok?: boolean; value?: any } | null | undefined

package/src/client/css-modules.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CSS Modules 的类型声明（仅服务 tsc 类型检查）。
+ *
+ * 客户端样式由 tsdown 的 `dsh-css-modules-inline` 插件在构建期内联：
+ * `.module.css` 被编译成 `{ <local>: '<hash>_<local>', ... }` 映射，
+ * 因此运行时拿到的是一个「类名 → 混淆后类名」的普通对象。
+ * 这里给 tsc 一个等价形状，避免 `import css from './x.module.css'` 报 TS2307。
+ */
+declare module '*.module.css' {
+  const classes: Readonly<Record<string, string>>
+  export default classes
+}

package/src/commands/insight-actions.js

@@ -5,7 +5,7 @@
 import { ProjectMemoryStore } from '../store.js'
 import { memoryRootFor } from '../util/fs.js'
 import { cfgInsight, GlobalStore, normalizeInsight, defaultGlobalFile, saveInsight, INSIGHT_KINDS } from '../insight-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 insSummary(ins, extra = {}) {
@@ -334,6 +334,7 @@ export function insightCommandDefinition(config, ctx) {
         const lineRaw = (invocation?.rawInput || '').trim()
         const raw = lineRaw.split(/\s+/).filter(Boolean)
         const root = projectRootFor(cwd)
+        if (!root) return { kind: 'error', text: NO_PROJECT_ROOT_NOTE }
         if (!raw[0]) return { kind: 'error', text: '[insight] 用法见面板' }
         const verb = raw[0]
         if (verb === 'list') {

package/src/commands/task-actions.js

@@ -2,17 +2,15 @@
 //   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}）`
 }
 
@@ -77,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)
@@ -127,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/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'
@@ -40,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({
@@ -75,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」选分支，
@@ -169,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/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()