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

package/src/client/slash.ts

@@ -0,0 +1,184 @@
+/**
+ * 自建 `/` 触发器源：把工作流的三个视图入口收进一个带图标和小节标题的「工作流」组。
+ *
+ * 为什么必须自建源：`/` 菜单里的「分组」就是触发器源（ui-input-trigger 的 roster），
+ * 而宿主 ui-commands 给目录行装配外观时只认第一方 definitionId 白名单
+ * （presentation.ts 的 HOST_FACES / SECTION_ROWS），且宿主 CommandDescriptor 只有
+ * name/description/input —— 没有 icon、没有分组、没有隐藏开关。第三方宿主命令因此
+ * 永远只是「指令」小节末尾一行纯文字。
+ *
+ * 两个宿主约束决定了这里的写法：
+ *  1. **分组标题走候选的 `section`，不走 `slash.menu` 词典。** 组标题查的是 `slash.menu`
+ *     namespace，而它由 ui-input-trigger 独占：`register('slash.menu','zh')` 会抛
+ *     "already has locale"，未知 key 则原样回显源名。MenuView 在「组内任一行带 section」时
+ *     干脆不渲染组标题行，只渲染 section 标题 —— 于是标题文案回到我们手里，还能按语言切换。
+ *  2. **只做增量，不抢宿主的分发。** 这里不实现 matchSpace / matchEnter，所以手敲 `/tasks`、
+ *     面板调 remote.commands.execute 全部走宿主原有路径。本源只是往菜单里多添一组行。
+ *
+ * 与「指令」组的重复：合并前插件注册了 /tasks、/task、/insight 三条宿主命令，菜单里就是三行
+ * 去不掉的原始行 —— 宿主命令只要注册就会出现在目录里，`commands.list()` 与
+ * `commands.execute()` 读同一个视图，`CommandDefinition` 也没有 hidden 字段，插件无法隐藏。
+ * 现在宿主只剩一条 /tasks（见 src/commands/workflow.js），重复降到一行；那一行也是插件
+ * 执行宿主侧工作的唯一通道（插件没有自己的 client→host RPC）。
+ */
+import type { ComponentType } from 'react'
+import { createTranslate, en, zh } from './locales.ts'
+import { IconChecklistOutline16, IconGlobeOutline16, IconLightOutline16 } from './icons.ts'
+
+/** 源的稳定标识：同一 trigger 内唯一，重复注册会抛错。 */
+export const SLASH_SOURCE_NAME = 'project-memory'
+
+/**
+ * 组的排序权重（越小越靠前，未设时默认 0）。
+ * 宿主内置源都取默认 0，所以 1 = 一定排在「指令 / 技能 / 子智能体」之后。
+ * 没有能同时满足「在宿主之后」与「在所有其他插件之前」的取值：其他插件若也留默认 0
+ * 就会排在我们前面。1 是最接近的折中，且不会去抢宿主主位置。
+ */
+export const SLASH_SOURCE_ORDER = 1
+
+/** 一行候选：候选 name 与标题同源（本地化文本），名称即身份、即标题。 */
+interface SlashRow {
+  /** 词典 key：既作候选 name（组内唯一身份）也作行标题。 */
+  readonly labelKey: string
+  /** 行描述词典 key。 */
+  readonly descriptionKey: string
+  /** 行图标；图标名按宿主版本自适应，见 icons.ts。 */
+  readonly icon: ComponentType<{ size?: number; className?: string }>
+  /** 额外搜索词：候选 name 是中文，拉丁输入（task / memory…）靠这些命中。 */
+  readonly match: readonly string[]
+  /** 点击后经 remote.commands.execute 执行的完整命令行。 */
+  readonly line: string
+}
+
+/** 菜单三行。顺序即渲染顺序；标题复用面板已有的 view.* 文案，保证与面板视图名一致。 */
+const ROWS: readonly SlashRow[] = [
+  {
+    labelKey: 'view.task',
+    descriptionKey: 'slash.tasks-desc',
+    icon: IconChecklistOutline16,
+    match: ['tasks', 'task'],
+    line: '/tasks',
+  },
+  {
+    labelKey: 'view.project',
+    descriptionKey: 'slash.project-desc',
+    icon: IconLightOutline16,
+    match: ['memory', 'project', 'insight'],
+    line: '/tasks insight list project',
+  },
+  {
+    labelKey: 'view.global',
+    descriptionKey: 'slash.global-desc',
+    icon: IconGlobeOutline16,
+    match: ['memory', 'global', 'insight'],
+    line: '/tasks insight list global',
+  },
+]
+
+/** 本插件的 client 上下文投影：只看得到这几个能力，避免把整个 cordis ctx 传进来。 */
+export interface SlashSourceDeps {
+  /** 会话服务（`sessions`）：把 sessionId 换回会话 scope，用于消费触发 token。 */
+  readonly sessions: any
+  /** 执行一条完整命令行；返回 composer 认得的 SubmitOutcome 形状。 */
+  run(session: any, line: string, attachments?: readonly unknown[]): Promise<{ kind: 'success' | 'error'; text?: string }>
+}
+
+/** 翻译函数签名（key 来自 ROWS，不是字面量，故不做类型约束）。 */
+type Translate = (key: string, params?: Record<string, string | number>) => string
+
+/** 按当前语言取翻译函数。 */
+function translator(ctx: any): Translate {
+  const dict = ctx?.locale?.getSnapshot?.()?.active === 'zh' ? zh : en
+  return createTranslate(dict) as unknown as Translate
+}
+
+/**
+ * 一轮候选：把三行装配成菜单行，再按查询与位置过滤。
+ *
+ * 三行都不接参数（动作全在面板卡片里），所以位置过滤只做一件事：行内出现的 `/` 多半是路径，
+ * 不弹这一整组（宿主对无 input 命令在前导/行内都放行，这里更保守）。
+ * @param t - 翻译函数。
+ * @param req - 宿主给的候选请求（query / position）。
+ * @returns 菜单行；永不抛出。
+ */
+export function buildSlashCandidates(t: Translate, req: any): readonly Record<string, unknown>[] {
+  if (req?.position !== undefined && req.position !== 'leading') return []
+  const query = typeof req?.query === 'string' ? req.query.trim().toLowerCase() : ''
+  const rows = ROWS.map((row) => {
+    const title = t(row.labelKey)
+    return {
+      name: title,
+      // label 与 name 相同 → MenuView 不渲染尾随别名（这些是视图入口，不是命令名）
+      label: title,
+      description: t(row.descriptionKey),
+      icon: row.icon,
+      // 每一行都带 section → MenuView 不渲染组标题行，只渲染这个标题。
+      section: t('slash.group'),
+      line: row.line,
+      terms: [title, ...row.match].map((term) => term.toLowerCase()),
+    }
+  })
+  return rows
+    .filter((row) => query === '' || row.terms.some((term) => term.startsWith(query)))
+    .map(({ terms: _terms, ...candidate }) => candidate)
+}
+
+/**
+ * 把触发 token 从草稿里删掉（span 做 CAS：草稿被改过就拒绝，什么都不动）。
+ * 这是宿主 command 源消费菜单点击的同一条契约事件。
+ * @returns true 表示确实消费掉了。
+ */
+function consumeSpan(deps: SlashSourceDeps, pick: any): boolean {
+  try {
+    const scope = deps.sessions?.scope?.(pick?.session?.sessionId)
+    if (!scope || typeof scope.bail !== 'function') return false
+    return scope.bail(scope, 'slash/input-consume-token', {
+      guard: { kind: 'span', span: pick.span },
+    }) === true
+  } catch (err) {
+    console.warn('[dsh-project-memory] slash token consume failed:', err)
+    return false
+  }
+}
+
+/**
+ * 一次菜单点击：消费掉触发 token 后立刻执行该行对应的命令行。
+ *
+ * 不返回 claim（回填 `/xxx ` 再等回车）：这三行都是「打开某个视图」，claim 会多要一次回车，
+ * 而且子动词（`insight list project`）也没法由一个 claim token 表达。消费失败时仍然执行，
+ * 只是草稿里残留的触发文本要用户自己清掉 —— 比回填一个会执行错命令的 claim 安全。
+ * @param t - 翻译函数（按当前语言把候选 name 映射回 ROWS）。
+ * @param deps - 会话服务与命令执行通道。
+ * @param pick - 宿主给的点击载荷。
+ * @returns PickOutcome；拿不到可用形状时返回 undefined（菜单照常关闭，草稿不动）。
+ */
+export function dispatchSlashPick(t: Translate, deps: SlashSourceDeps, pick: any): unknown {
+  const title = pick?.candidate?.name
+  if (typeof title !== 'string' || title === '') return undefined
+  const row = ROWS.find((candidate) => t(candidate.labelKey) === title)
+  if (row === undefined) return undefined
+  consumeSpan(deps, pick)
+  void deps.run(pick.session, row.line, []).catch((err: unknown) => {
+    console.warn(`[dsh-project-memory] ${row.line} failed:`, err)
+  })
+  return 'handled'
+}
+
+/**
+ * 造出注册给 `ctx.inputTriggers.registerSource` 的源对象。
+ * @param ctx - client 根上下文（只读 locale）。
+ * @param deps - 会话服务与命令执行通道。
+ * @returns 触发器源；只依赖宿主的公开契约字段。
+ */
+export function createSlashSource(ctx: any, deps: SlashSourceDeps): Record<string, unknown> {
+  const t = translator(ctx)
+  return {
+    trigger: '/',
+    name: SLASH_SOURCE_NAME,
+    order: SLASH_SOURCE_ORDER,
+    // 组标题不渲染：行上都有 section，MenuView 会用 section 标题取代它。
+    showGroupTitle: false,
+    candidates: async (_session: unknown, req: any) => buildSlashCandidates(t, req),
+    onPick: (pick: any) => dispatchSlashPick(t, deps, pick),
+  }
+}

package/src/commands/insight-actions.js

@@ -6,6 +6,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 { fencedJson, invocationContext } from './invocation.js'
 
 function insSummary(ins, extra = {}) {
   const s = ins || {}
@@ -225,7 +226,9 @@ const KIND_CONTENT = {
   procedure: ['steps', 'trigger'],
   experience: ['problem', 'solution'],
 }
-const ALL_CONTENT = ['body', 'pattern', 'fix', 'problem', 'solution', 'choice', 'reason', 'steps', 'trigger']
+// 切 kind 时要清掉的内容字段。**不含 trigger**：任何 kind 都可以带 authored trigger，
+// 放进这里会在 lesson↔decision 之间切换时把自动注入能力一并删掉。
+const ALL_CONTENT = ['body', 'pattern', 'fix', 'problem', 'solution', 'choice', 'reason', 'steps']
 
 /** 编辑既有条目（title/kind/正文/trigger 等白名单字段）。任务级按 id 在任务池定位。 */
 export function editMemoryItem({ store, gs, scope, id, fields }) {
@@ -244,10 +247,18 @@ export function editMemoryItem({ store, gs, scope, id, fields }) {
       }
       if (key === 'trigger') {
         if (!v || typeof v !== 'object') continue
-        item.trigger = {
-          keywords: Array.isArray(v.keywords) ? v.keywords.map(String) : [],
-          ...(Array.isArray(v.scope) ? { scope: v.scope.map(String) } : {}),
-        }
+        // 合并而非重建：只改传进来的成员，when/guard/prevents 等 authored 触发面必须原样保留，
+        // 否则一次 /insight edit 就会把自动注入的 trigger 降级成 legacy keywords。
+        const next = { ...(item.trigger || {}) }
+        if (Array.isArray(v.keywords)) next.keywords = v.keywords.map(String)
+        if (Array.isArray(v.scope)) next.scope = v.scope.map(String)
+        if (Array.isArray(v.actions)) next.actions = v.actions.map(String)
+        if (Array.isArray(v.paths)) next.paths = v.paths.map(String)
+        if (Array.isArray(v.symbols)) next.symbols = v.symbols.map(String)
+        if (v.when && typeof v.when === 'object') next.when = v.when
+        if (v.guard && typeof v.guard === 'object') next.guard = v.guard
+        if (typeof v.prevents === 'string') next.prevents = v.prevents
+        item.trigger = next
         changed = true
         continue
       }
@@ -300,22 +311,26 @@ export function editMemoryItem({ store, gs, scope, id, fields }) {
   return { ok: true, text: '已更新记忆条目' }
 }
 
-function jsonText(payload, note) {
-  return `${note}\n\n\`\`\`json\n${JSON.stringify(payload)}\n\`\`\``
-}
-
-/** /insight <verb> <args…>：list [task|project|global] | confirm/promote/demote/archive/restore/delete <id> [taskId] */
+/**
+ * 记忆动作处理器：`list [task|project|global]` | `confirm/promote/demote/archive/restore/delete <scope> <id> [taskId]`
+ * 等。
+ *
+ * ⚠️ 这里返回的定义**不再作为宿主命令注册**：合并后唯一的用户命令是 `/tasks`（见 workflow.js），
+ * 本处理器是它的 `insight` 子动词分支（`/tasks insight <动作> …`），由工作流卡片按钮经
+ * 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 insightCommandDefinition(config, ctx) {
   return {
     name: 'insight',
-    description: '记忆视图动作（面板按钮调用）：/insight list project|global|task；/insight <confirm|promote|demote|archive|restore|delete> <scope> <id> [taskId]',
+    description: '记忆视图动作（面板按钮调用）：/tasks insight list project|global|task；/tasks insight <confirm|promote|demote|archive|restore|delete> <scope> <id> [taskId]',
     input: { hint: 'list [scope] | <动作> <scope> <id> [taskId]' },
     handler: (invocation) => {
       try {
-        const agent = invocation?.agent
-        const sid = agent?.id || agent?.session?.id
-        const session = sid && agent?.ctx ? agent.ctx.sessions?.get(sid) : (agent?.session || null)
-        const cwd = session?.header?.cwd || agent?.session?.header?.cwd
+        const { cwd } = invocationContext(invocation)
         const lineRaw = (invocation?.rawInput || '').trim()
         const raw = lineRaw.split(/\s+/).filter(Boolean)
         const root = projectRootFor(cwd)
@@ -326,7 +341,7 @@ export function insightCommandDefinition(config, ctx) {
           const store = new ProjectMemoryStore(memoryRootFor(root, config.memoryDir)).load()
           const gs = new GlobalStore(cfgInsight(config).globalFile || defaultGlobalFile()).load()
           const payload = listInsights(store, gs, scope)
-          return { kind: 'success', text: jsonText(payload, `记忆 ${scope}：${payload.count} 条`) }
+          return { kind: 'success', text: fencedJson(`记忆 ${scope}：${payload.count} 条`, JSON.stringify(payload)) }
         }
         if (verb === 'save') {
           // /insight save <scope> <json>（新建/合并；project|global）

package/src/commands/invocation.js

@@ -0,0 +1,36 @@
+/**
+ * 命令处理器的公共接线：/tasks、/task、/insight 三个定义此前各自复制了
+ * 「解析 CommandInvocation → 会话与 cwd」和「拼 JSON 围栏载荷」两段代码。
+ * 集中在这里，语义只在一处维护。
+ */
+
+/**
+ * 从命令调用里解出会话上下文。
+ *
+ * `sid` 优先取 `agent.id`；`session` 优先走 `sessions` 服务（拿到的是宿主实时会话，
+ * 带 append 等能力），服务缺失或不可用时退回 `agent.session`。
+ * @param {object} invocation - 宿主 CommandInvocation（handler 的入参）。
+ * @returns {{agent: object|undefined, sid: string|undefined, session: object|null, cwd: string|undefined}}
+ */
+export function invocationContext(invocation) {
+  const agent = invocation?.agent
+  const sid = agent?.id || agent?.session?.id
+  const fromService = sid && agent?.ctx ? agent.ctx.sessions?.get(sid) : null
+  // sessions 服务缺失**或查不到**时都退回 agent.session（文档承诺的降级路径）。
+  // 旧写法只在 agent.ctx 不存在时退回：服务在、但 get 返回 undefined 时 session 直接是 undefined，
+  // /task switch|todos|unbind 于是静默跳过 session.append（宿主 todo 同步失效）。
+  const session = fromService || agent?.session || null
+  const cwd = session?.header?.cwd || agent?.session?.header?.cwd
+  return { agent, sid, session, cwd }
+}
+
+/**
+ * 统一的命令输出载荷：人类可读摘要 + ```json 块。
+ * 客户端命令节点按尾部 JSON 解析并渲染面板，因此三个命令共用同一格式。
+ * @param {string} note - 人类可读摘要（可多行）。
+ * @param {string} payload - 已序列化的 JSON 载荷。
+ * @returns {string}
+ */
+export function fencedJson(note, payload) {
+  return `${note}\n\n\`\`\`json\n${payload}\n\`\`\``
+}

package/src/commands/task-actions.js

@@ -8,8 +8,7 @@ import { projectRootFor, adoptStepsToSession, shouldAdoptToHost } from '../setup
 import { renderTaskSnapshot, buildTaskPayload } from './tasks.js'
 import { fireReflect } from '../reflection-pipeline.js'
 import { resolveRoute } from '../llm-route.js'
-
-const VERBS = { switch: 'switch', archive: 'archive' }
+import { fencedJson, invocationContext } from './invocation.js'
 
 function describeTask(t) {
   const done = (t.steps || []).filter((s) => s.status === 'completed').length
@@ -17,6 +16,23 @@ function describeTask(t) {
   return `「${t.title}」（步骤 ${done}/${total}）`
 }
 
+/**
+ * raw 去掉前 n 个空白分隔 token 后的**原始剩余文本**（保留内部空白与引号）。
+ * 旧写法 `raw.split(/\s+/).slice(n).join(' ')` 会把标题/JSON 里的连续空格压成一个，
+ * `/tasks rename <id> "a  b"` 于是改名成 "a b"。
+ */
+function restAfter(raw, n) {
+  let i = 0
+  let seen = 0
+  while (i < raw.length && seen < n) {
+    while (i < raw.length && /\s/.test(raw[i])) i++
+    if (i >= raw.length) break
+    while (i < raw.length && !/\s/.test(raw[i])) i++
+    seen++
+  }
+  return raw.slice(i).replace(/^\s+/, '')
+}
+
 function withTaskSnapshot(config, cwd, sid, store, note) {
   const tasks = store.getTasks()
   const active = tasks.filter((t) => !t.archived)
@@ -24,20 +40,28 @@ function withTaskSnapshot(config, cwd, sid, store, note) {
   const boundId = sid ? store.getBoundTaskId(sid) : null
   const human = `项目 ${projectRootFor(cwd)}\n${note}\n任务: ${active.length} 套${archived ? `（归档 ${archived}）` : ''}`
   const payload = buildTaskPayload(active, boundId, archived)
-  return { kind: 'success', text: `${human}\n\n\`\`\`json\n${payload}\n\`\`\`` }
+  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 {
-        const agent = invocation?.agent
-        const sid = agent?.id || agent?.session?.id
-        const session = sid && agent?.ctx ? agent.ctx.sessions?.get(sid) : (agent?.session || null)
-        const cwd = session?.header?.cwd || agent?.session?.header?.cwd
+        const { session, sid, cwd } = invocationContext(invocation)
         const raw = (invocation?.rawInput || '').trim()
         const [verb, taskId, ...rest] = raw.split(/\s+/)
 
@@ -70,7 +94,7 @@ export function taskCommandDefinition(config, ctx) {
         // /task rename <任务id> <json标题> —— 双击任务标题改名
         if (verb === 'rename') {
           if (!taskId) return { kind: 'error', text: '[task] rename 需要任务 id（由卡片双击调用）' }
-          const payload = raw.split(/\s+/).slice(2).join(' ').trim()
+          const payload = restAfter(raw, 2).trim()
           let title = payload
           try {
             const parsed = JSON.parse(payload)
@@ -92,7 +116,7 @@ export function taskCommandDefinition(config, ctx) {
         // /task todos <json> —— 卡片双击编辑步骤后，把整份新清单写回绑定任务并推宿主
         // （与模型 todo_write 同一套数据，只是发起方是用户面板）
         if (verb === 'todos') {
-          const rawJson = raw.split(/\s+/).slice(1).join(' ').trim()
+          const rawJson = restAfter(raw, 1).trim()
           let todos
           try {
             todos = JSON.parse(rawJson)
@@ -126,7 +150,7 @@ export function taskCommandDefinition(config, ctx) {
           return withTaskSnapshot(config, cwd, sid, store, note)
         }
 
-        if (verb === VERBS.switch) {
+        if (verb === 'switch') {
           const task = store.getTask(taskId)
           if (!task) return { kind: 'error', text: `[task] 找不到任务: ${taskId}（/tasks 查看）` }
           const prevBound = sid ? store.getBoundTaskId(sid) : null
@@ -149,7 +173,7 @@ export function taskCommandDefinition(config, ctx) {
           return withTaskSnapshot(config, cwd, sid, store, note)
         }
 
-        if (verb === VERBS.archive) {
+        if (verb === 'archive') {
           const task = store.getTask(taskId)
           if (!task) return { kind: 'error', text: `[task] 找不到任务: ${taskId}（/tasks 查看）` }
           if (task.archived) return { kind: 'error', text: `[task] 已归档: ${task.title}` }
@@ -169,31 +193,3 @@ export function taskCommandDefinition(config, ctx) {
     },
   }
 }
-
-// 保留语义别名：/task-switch、/task-archive（仅当前端/旧入口用）
-export function taskSwitchCommandDefinition(config) {
-  const base = taskCommandDefinition(config)
-  return {
-    ...base,
-    name: 'task-switch',
-    handler: (invocation) => {
-      const id = (invocation?.rawInput || '').trim().split(/\s+/)[0]
-      return base.handler({ ...invocation, rawInput: id ? `switch ${id}` : '' })
-    },
-  }
-}
-
-export function taskArchiveCommandDefinition(config) {
-  const base = taskCommandDefinition(config)
-  return {
-    ...base,
-    name: 'task-archive',
-    handler: (invocation) => {
-      const id = (invocation?.rawInput || '').trim().split(/\s+/)[0]
-      return base.handler({ ...invocation, rawInput: id ? `archive ${id}` : '' })
-    },
-  }
-}
-
-// renderTaskSnapshot 引用保留，供外部（测试/工具）使用
-export { renderTaskSnapshot }

package/src/commands/tasks.js

@@ -4,6 +4,7 @@
 import { memoryRootFor } from '../util/fs.js'
 import { ProjectMemoryStore } from '../store.js'
 import { projectRootFor } from '../setup/taskbridge.js'
+import { fencedJson, invocationContext } from './invocation.js'
 
 function timeAgo(iso) {
   const diff = Date.now() - new Date(iso).getTime()
@@ -15,12 +16,21 @@ function timeAgo(iso) {
   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')
+}
+
 export function buildTaskPayload(tasks, boundId, archived) {
   return JSON.stringify({
     tasks: tasks.map((t) => ({
       id: t.id,
       title: t.title,
-      steps: (t.steps || []).map((s) => ({ content: s.content || s.text, status: s.status })),
+      steps: (t.steps || []).map((s) => ({ content: stepContent(s), status: stepStatus(s) })),
       files: (t.files || []).map((f) => ({ path: f, line: undefined })),
       lastActiveAt: t.lastActiveAt,
       updatedAt: t.updatedAt,
@@ -47,18 +57,16 @@ export function renderTaskSnapshot(config, cwd, sid) {
 
   if (!active.length) {
     const payload = buildTaskPayload([], boundId, archived)
-    return {
-      kind: 'success',
-      text: `项目 ${root}\n任务记录: 0 套${archived ? `（归档 ${archived}）` : ''}。让模型开始干活并维护 todo 清单后会自动建档。\n\n\`\`\`json\n${payload}\n\`\`\``,
-    }
+    const note = `项目 ${root}\n任务记录: 0 套${archived ? `（归档 ${archived}）` : ''}。让模型开始干活并维护 todo 清单后会自动建档。`
+    return { kind: 'success', text: fencedJson(note, payload) }
   }
   const lines = [`项目 ${root}`, `任务: ${active.length} 套${archived ? `（归档 ${archived}）` : ''}`, '']
   for (const t of active) {
-    const done = (t.steps || []).filter((s) => s.status === 'completed').length
+    const done = (t.steps || []).filter((s) => stepStatus(s) === 'completed').length
     const total = (t.steps || []).length
     const progress = total ? `${done}/${total}` : '无步骤'
-    const inProgress = (t.steps || []).find((s) => s.status === 'in_progress')
-    const step = inProgress ? ` · 当前: ${inProgress.content}` : ''
+    const inProgress = (t.steps || []).find((s) => stepStatus(s) === 'in_progress')
+    const step = inProgress ? ` · 当前: ${stepContent(inProgress)}` : ''
     const marker = bound && bound.id === t.id ? '（本会话绑定）' : ''
     const files = (t.files || []).slice(0, 8)
     const fileLine = files.length ? `\n  文件: ${files.join(', ')}${t.files.length > 8 ? ' …' : ''}` : ''
@@ -67,7 +75,7 @@ export function renderTaskSnapshot(config, cwd, sid) {
   lines.push('', '续接/改名/归档：直接告诉模型（list_tasks / select_task / archive_task）。')
   const humanText = lines.join('\n')
   const payload = buildTaskPayload(active, boundId, archived)
-  return { kind: 'success', text: `${humanText}\n\n\`\`\`json\n${payload}\n\`\`\`` }
+  return { kind: 'success', text: fencedJson(humanText, payload) }
 }
 
 export function tasksCommandDefinition(config, ctx) {
@@ -76,10 +84,7 @@ export function tasksCommandDefinition(config, ctx) {
     description: '查看本项目的任务清单（几套任务、进度、涉及文件、当前绑定）',
     handler: (invocation) => {
       try {
-        const agent = invocation?.agent
-        const sid = agent?.id || agent?.session?.id
-        const session = sid && agent?.ctx ? agent.ctx.sessions?.get(sid) : (agent?.session || null)
-        const cwd = session?.header?.cwd || agent?.session?.header?.cwd
+        const { cwd, sid } = invocationContext(invocation)
         return renderTaskSnapshot(config, cwd, sid)
       } catch (err) {
         return { kind: 'error', text: `[tasks] ${err?.message || err}` }

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/enhancer.js

@@ -19,7 +19,14 @@ function acceptTsVersion(mod) {
 }
 
 export function initTypeScript(config) {
-  if (config?.enableTypeScript === false) return null
+  if (config?.enableTypeScript === false) {
+    // 显式关闭要把已解析的模块放掉：否则 enqueueEnhance 的 `if (!ts)` 仍会放行，
+    // 配置上关了、增强器照跑。
+    ts = null
+    tsPath = null
+    tsVersion = null
+    return null
+  }
   if (ts) return ts
 
   // 1. 配置指定路径
@@ -265,7 +272,9 @@ export function deepParseWithTS(filePath, content) {
         line: getLine(node)
       })
     } else if (ts.isTypeAliasDeclaration(node)) {
-      const typeStr = node.type ? getTypeStr(checker.getTypeAtLocation(node.type)) : 'any'
+      // checker.getTypeAtLocation(node.type) 对别名返回的是**别名自身**，于是
+      // `type X = { a: string }` 变成 `X= X -- f:1`。直接用类型节点的源码文本。
+      const typeStr = node.type ? node.type.getText().replace(/\s+/g, ' ').slice(0, 200) : 'any'
       symbols.push({
         name: node.name.getText(),
         kind: 'type',