@zaofan/dsh-qqbot 1.8.4 → 1.8.8

package/examples/ext-tools/session_send.mjs

@@ -0,0 +1,141 @@
+/**
+ * session_send.mjs — 跨会话/跨工作区投递·**发送工具**（照抄 qqbot 插件的**入站模式**）
+ *
+ * ── 定案（主人 2026-10-12）────────────────────────────────────────────
+ *   · 一律**模拟用户消息**（`source.kind='user'`）。
+ *   · **不用 `session.append`** —— 它的消息没被任何回合 claim，前端会当成
+ *     "待发送输入"挂到**输入框**上方。改用 `agent.inject`。
+ *   · **忙时插话、空闲唤醒**（原话见 qqbot `dist/features/qq-user-questions.js:646`）：
+ *       忙(回合进行中) → `agent.inject` = 宿主 `send(msg,'next-step',wakeup:false)`
+ *                        —— 进当前回合的下一个轮次边界，她本轮就读到；**不排下一回合队列**。
+ *       空闲           → `agent.followup` 唤醒它接着处理。
+ *
+ * ── 两种调用意图 ──────────────────────────────────────────────────────
+ *   mode='append'（默认，不唤醒）→ 一律 `inject`（插话通道，静默进上下文）
+ *   mode='wake'  （要它立刻处理）→ 忙 `inject` / 空闲 `followup`
+ *
+ * ── 保留的两个工程细节 ────────────────────────────────────────────────
+ *   ① 先拿 live agent（`agents.get` → 没有就 `agents.resume({resumeSessionId})`）
+ *   ② 投递后自检：看该 agent 的 inbox 队列长度有没有变化，如实回报
+ */
+export const __TOOL_VERSION__ = 'send-v8-20261012-忙插话/闲唤醒';
+
+export const isInjectableMessage = (m) => {
+  if (!m || typeof m !== 'object' || Array.isArray(m)) return false;
+  if (typeof m.role !== 'string' || !m.role) return false;
+  if (!Array.isArray(m.content) || m.content.length === 0) return false;
+  const s = m.source;
+  if (!s || typeof s !== 'object' || Array.isArray(s)) return false;
+  return typeof s.kind === 'string' && !!s.kind && s.kind !== 'plugin';
+};
+const short = (id) => { const s = String(id ?? ''); return s.startsWith('session-') ? s.slice(8, 16) : s.slice(0, 8); };
+const rid = (p) => (globalThis.crypto?.randomUUID?.() ?? (p + '-' + Date.now().toString(36) + Math.random().toString(36).slice(2, 8)));
+/** 队列长度（inject 的自检依据） */
+function queueLen(agent) {
+  try {
+    const q = agent?.inbox;
+    const a = Array.isArray(q?.nextStep) ? q.nextStep.length : 0;
+    const b = Array.isArray(q?.nextTurn) ? q.nextTurn.length : 0;
+    return a + b;
+  } catch { return -1; }
+}
+function isBusy(agent) {
+  try {
+    const st = String(agent?.status ?? agent?.phase ?? '');
+    return st !== '' && st !== 'idle';
+  } catch { return false; }
+}
+
+export default {
+  name: 'session_send',
+  expose: 'all',
+  description:
+    '跨会话/跨工作区投递（**模拟用户消息**，走插件同款入站模式：忙插话 / 闲唤醒）。目标用 session_id，不填=创建自己的那个会话。' +
+    'mode=append（默认）用 inject 静默进对方上下文、不唤醒；mode=wake 忙时 inject 插话、空闲 followup 唤醒。' +
+    '目标非 live 会先 resume；投递后自检队列并如实回报。',
+  inputSchema: {
+    text: { type: 'string', description: '要投递的正文（必填）' },
+    session_id: { type: 'string', description: '目标会话 id（完整）；不填=创建自己的那个会话' },
+    mode: { type: 'string', description: 'append=inject 静默进上下文不唤醒（默认） / wake=忙插话·闲唤醒' },
+    notify: { type: 'boolean', description: 'true=正文前加一行「【来自会话 <我的完整 session id>】」（默认 true；对方据此可直接回投）' },
+  },
+
+  async run(args = {}, env = {}) {
+    const text = String(args?.text ?? '').trim();
+    if (!text) return { ok: false, msg: '缺少 text' };
+
+    const ctx = env?.ctx ?? null;
+    const root = ctx && typeof ctx === 'object' && ctx.root ? ctx.root : ctx;
+    if (!root?.get) return { ok: false, msg: "拿不到宿主 ctx（需要 expose:'all'）" };
+    const svc = (n) => { try { return root.get(n); } catch { return undefined; } };
+    const agents = svc('agents'); const sessions = svc('sessions'); const sc = svc('sessionController');
+    if (!agents || typeof agents.get !== 'function') return { ok: false, msg: '宿主没挂 agents 服务' };
+
+    const me = String(env?.exec?.agent?.id ?? env?.exec?.sessionId ?? '').trim();
+    const mode = String(args?.mode ?? 'append').trim() === 'wake' ? 'wake' : 'append';
+    const out = [];
+
+    let targetId = String(args?.session_id ?? '').trim();
+    let srcNote = '显式指定';
+    if (!targetId) {
+      if (!me) return { ok: false, msg: '既没给 session_id，也拿不到"我是谁"' };
+      srcNote = '创建者(parentSession)';
+      try { targetId = String(sessions?.get?.(me)?.header?.parentSession ?? '').trim(); } catch { /* ignore */ }
+      if (!targetId) return { ok: false, msg: '本会话没有创建者 → 请显式给 session_id' };
+    }
+
+    // ★ 主人 2026-10-12 定：模拟用户消息的**首行直接给出源会话 id**（完整 id，不是短号）——
+    //   对方据此就能回投给我，不用再靠血缘字段去猜。
+    const body = (args?.notify === false || !me) ? text : '【来自会话 ' + me + '】\n' + text;
+    const msg = { id: rid('snd'), role: 'user', content: [{ type: 'text', text: body }], source: { kind: 'user' } };
+    if (!isInjectableMessage(msg)) return { ok: false, msg: '内部错误：消息形状自检不过（已中止）' };
+
+    // ① live agent（没有就 resume）
+    let agent = null, resumed = false;
+    try { agent = agents.get(targetId) ?? null; } catch { /* ignore */ }
+    if (!agent && typeof agents.resume === 'function') {
+      try { const h = await agents.resume({ resumeSessionId: targetId }); agent = h?.agent ?? agents.get?.(targetId) ?? null; resumed = !!agent; }
+      catch (e) { out.push('resume 失败: ' + String(e?.message ?? e).slice(0, 110)); }
+    }
+    if (!agent) return { ok: false, msg: `投递失败（${short(targetId)}…）：目标不是 live 且 resume 没成功\n` + out.join('\n') };
+
+    // ② 忙闲 → 选通道（照抄插件"忙时插话、空闲唤醒"）
+    const busy = isBusy(agent);
+    const before = queueLen(agent);
+    let via = ''; const errs = [];
+    const doInject = async (why) => { await agent.inject(msg); via = `agent.inject（${why}）`; };
+    const doFollow = async (why) => { await agent.followup(msg); via = `agent.followup（${why}）`; };
+
+    try {
+      if (mode === 'append') {
+        await doInject('不唤醒·插话通道');
+      } else if (busy) {
+        await doInject('忙 → 插话，不排下一回合');
+      } else {
+        try { await doFollow('空闲 → 唤醒'); }
+        catch (e) { errs.push('followup→' + String(e?.message ?? e).slice(0, 80)); await doInject('followup 失败 → 回落插话'); }
+      }
+    } catch (e) { errs.push('投递→' + String(e?.message ?? e).slice(0, 100)); }
+
+    // ③ 兜底 sessionController.prompt
+    if (!via && sc && typeof sc.prompt === 'function') {
+      const req = { requestId: rid('req'), sessionId: targetId, mode: 'queue', content: [{ type: 'text', text: body }] };
+      const sig = new AbortController().signal;
+      for (const [lb, fn] of [['sc.prompt(req,sig)', () => sc.prompt(req, sig)], ['sc.prompt(req)', () => sc.prompt(req)]]) {
+        try { await fn(); via = lb + '（兜底，会开队列回合）'; break; } catch (e) { errs.push(lb + '→' + String(e?.message ?? e).slice(0, 80)); }
+      }
+    }
+
+    if (!via) return { ok: false, msg: `投递失败（${short(targetId)}…）\n` + (out.join('\n') + '\n') + '尝试明细: ' + errs.join(' | ') };
+
+    const after = queueLen(agent);
+    const landed = before >= 0 && after >= 0 ? after > before : null;
+    out.push(`队列自检: ${before} → ${after}` + (landed === true ? ' ✅ 已入队' : landed === false ? ' ⚠️ 队列数未变（可能被立即消费，也可能没进去）' : ' ? 无法判定'));
+    out.push(`目标忙闲: ${busy ? '忙（回合进行中）' : '空闲'}`);
+    return {
+      ok: true,
+      msg: `✅ 已投递到 ${short(targetId)}…（${srcNote}；用户消息；方式 ${via}；${resumed ? '已 resume；' : ''}` +
+        `${mode === 'wake' ? '意图=唤醒' : '意图=静默'}）` + (out.length ? '\n' + out.join('\n') : ''),
+    };
+  },
+};

package/examples/ext-tools/session_watch.mjs

@@ -0,0 +1,93 @@
+/**
+ * session_watch.mjs — 查看/补挂「回合结束回灌」钩子
+ *
+ * 配合 session_create 用：创建时会自动挂钩子（session_create → lib/session_watch_lib.register）。
+ * 本工具负责：
+ *   · list（默认）：列出正在盯的子会话（子 id / 父 id / 标签 / 是否已攒到正文 / 已结算几次）
+ *   · attach：给一个"已存在的子会话"补挂钩子（创建时漏挂、或插件重启后钩子丢了的情况）
+ *   · detach：取消盯某个子会话
+ * ⚠️ 主人要求这类工具不给全部会话用：已落地 `expose: 'qq'`（2026-10-12），只在 QQ 会话注册。
+ */
+import { statSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+/**
+ * 带版本号地加载共用库 —— **必须这么加载**。
+ *
+ * 原因同 session_create.mjs：插件只给**工具文件本身**的 import 加了 `?v=<mtime>`，
+ * 工具内部裸路径 import 会被 ESM 模块缓存永久命中 ⇒ 改 `tools/lib/` 热刷不生效。
+ * （这里原来是顶层静态 import，等于永远锁死在插件启动那一刻的旧版本。）
+ */
+async function loadWatchLib() {
+  const url = new URL('./lib/session_watch_lib.mjs', import.meta.url);
+  let v = '0';
+  try { v = String(statSync(fileURLToPath(url)).mtimeMs); } catch { /* 拿不到 mtime 就退回裸 import */ }
+  return import(v === '0' ? url.href : `${url.href}?v=${v}`);
+}
+
+/** 进程内自己维护的"取消盯梢"集合（库只管挂，取消在本工具侧记录） */
+const detached = new Set();
+
+export default {
+  name: 'session_watch',
+  // ★ 2026-10-12：**父会话专用**（"我作为父"去挂/摘回灌钩子）⇒ 不给子会话看。
+  // 只注册到 QQ 会话（子会话不可见）—— "我作为父"才需要挂/摘回灌钩子。
+  expose: 'qq',
+  description:
+    '查看/补挂「回合结束回灌」钩子：默认列出正在盯的子会话与状态；attach=给指定子会话补挂（子会话 id + 父会话 id）；detach=取消盯梢。' +
+    '（本工具是**兜底**通道：正常情况下让子会话自己用 send_message 回执即可。）',
+  inputSchema: {
+    action: { type: 'string', description: 'list（默认）=看状态 / attach=给已存在的子会话补挂 / detach=取消盯梢' },
+    child_session_id: { type: 'string', description: 'attach 或 detach 时要指定的子会话 id' },
+    parent_agent_id: { type: 'string', description: 'attach 时填**父会话 id**（历史上叫"父 agent id"，指的是同一个东西；不填＝用"我自己这个会话"）' },
+    label: { type: 'string', description: 'attach 时的标签，便于记认（可选）' },
+  },
+
+  async run(args = {}, env = {}) {
+    const ctx = env?.ctx ?? null;
+    const root = ctx && typeof ctx === 'object' && ctx.root ? ctx.root : ctx;
+    if (!root?.get) return { ok: false, msg: '拿不到宿主 ctx（需要 expose:\'all\'）' };
+
+    const lib = await loadWatchLib();
+
+    const action = String(args?.action ?? 'list').toLowerCase();
+    const p = (n) => String(n).padStart(2, '0');
+    const fmt = (t) => {
+      if (!t) return '—';
+      const d = new Date(t);
+      return Number.isNaN(d.getTime()) ? '—' : `${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+    };
+
+    if (action === 'attach' || action === '补挂') {
+      const child = String(args?.child_session_id ?? '').trim();
+      const parent = String(args?.parent_agent_id ?? env?.exec?.agent?.id ?? '').trim();
+      if (!child) return { ok: false, msg: 'attach 需要 child_session_id' };
+      if (!parent) return { ok: false, msg: 'attach 需要 parent_agent_id（不填会用"我自己"）' };
+      detached.delete(child);
+      const r = await lib.register(root, { parentAgentId: parent, childSessionId: child, label: String(args?.label ?? '') });
+      return { ok: !String(r).startsWith('未挂'), msg: 'attach → ' + r };
+    }
+
+    if (action === 'detach' || action === '取消') {
+      const child = String(args?.child_session_id ?? '').trim();
+      if (!child) return { ok: false, msg: 'detach 需要 child_session_id' };
+      detached.add(child);
+      return { ok: true, msg: `已从盯梢名单移除 ${child.slice(0, 8)}…（注：钩子本身是全局一个，这里只是不再为它回灌）` };
+    }
+
+    // list
+    const items = lib.listWatching().filter((x) => !detached.has(x.childSessionId));
+    if (!items.length) {
+      return {
+        ok: true,
+        msg: '【回合结束回灌】当前没有盯着任何子会话。\n用 session_create 建会话时会自动挂；也可以用 attach 给已存在的子会话补挂。',
+      };
+    }
+    const lines = items.map(
+      (x) =>
+        `   · 子 ${x.shortId ?? x.childSessionId.slice(0, 8)}… → 父 ${x.parentShortId ?? x.parentAgentId.slice(0, 8)}…` +
+        `${x.label ? '  [' + x.label + ']' : ''}  攒到正文=${x.hasText ? 'Y' : 'N'}  已结算=${x.turnsSeen} 次  上次回灌=${fmt(x.lastFiredAt)}`,
+    );
+    return { ok: true, msg: `【回合结束回灌】正在盯 ${items.length} 个子会话：\n` + lines.join('\n') };
+  },
+};

package/examples/ext-tools/sessions_list.mjs

@@ -0,0 +1,180 @@
+/**
+ * sessions_list.mjs — 列出 DSH 的工作区与各会话（跨工作区 / 跨会话，纯只读）
+ *
+ * 定位：这是「把子代理那套搬到跨会话级」的第 1 块积木 —— 先能看见，再谈操作。
+ * expose: 'all' ⇒ 所有通道（QQ / Web / 终端…）的会话都能用；env.ctx 是宿主的 cordis ctx。
+ *
+ * 数据来源（都是宿主现成服务，不自己扫盘）：
+ *   · ctx.workspaceRegistry  （@deepseek-ai/dsh-workspace）      —— 有序、持久的工作区项目列表
+ *   · ctx.sessionQuery       （@deepseek-ai/dsh-session-query）  —— 列会话（最新在前）、过滤、trace
+ * ⚠️ 取服务用 cordis 运行时 `ctx.get(name)`，不需要 inject（见 qqbot 的实测经验）；
+ *   并且优先用 `ctx.root`（插件根作用域）—— 会话作用域的 ctx 会随会话切换而失效。
+ *
+ * 失败哲学：任何一个服务缺失都只降级、不报错中断 —— 把"哪些服务可用"如实报出来，
+ *          方便在别的 DSH 版本上继续排查。
+ */
+const WORKSPACE_SERVICE = 'workspaceRegistry';
+const SESSION_SERVICE = 'sessionQuery';
+/** 探测用的候选服务名（有就报出来，便于后续工具挑正确的那个） */
+const PROBE = [WORKSPACE_SERVICE, SESSION_SERVICE, 'sessions', 'sessionPersistence', 'tools', 'systemPrompt', 'agents', 'goals'];
+
+/** 宽松取字段：宿主返回结构可能随版本变，这里按候选名依次试 */
+function pick(obj, names) {
+  if (!obj || typeof obj !== 'object') return undefined;
+  for (const n of names) {
+    const v = obj[n];
+    if (v !== undefined && v !== null) return v;
+  }
+  const h = obj.header;
+  if (h && typeof h === 'object') {
+    for (const n of names) {
+      const v = h[n];
+      if (v !== undefined && v !== null) return v;
+    }
+  }
+  return undefined;
+}
+
+/** 时间戳 → 本地 MM-dd HH:mm（吃 number / string / Date） */
+function fmtTime(v) {
+  if (v === undefined || v === null) return '';
+  try {
+    const d = v instanceof Date ? v : new Date(typeof v === 'number' ? v : String(v));
+    if (Number.isNaN(d.getTime())) return '';
+    // ⚠️ 用 UTC 字段显示：实测宿主把**本地时间**当 UTC 存
+    //   （createdAt=1791762071432 → UTC 23:41 才与主人的实际时间对得上；按本地读会多 8 小时）。
+    const p = (n) => String(n).padStart(2, '0');
+    return `${p(d.getUTCMonth() + 1)}-${p(d.getUTCDate())} ${p(d.getUTCHours())}:${p(d.getUTCMinutes())}`;
+  } catch { return ''; }
+}
+
+function safeGet(root, name) {
+  try { return root.get(name); } catch { return undefined; }
+}
+
+export default {
+  name: 'sessions_list',
+  description:
+    '列出 DSH 的工作区及其会话（跨工作区 / 跨会话）：默认按最新活跃在前，可用 limit 控制条数，可只看某个工作区。纯只读。',
+  expose: 'all',
+  inputSchema: {
+    workspace: { type: 'string', description: '只看标题/路径里含这段文字的工作区（可选；不填=全部）' },
+    limit: { type: 'integer', description: '每个工作区最多列几个会话（默认 10，上限 50）' },
+    debug: { type: 'boolean', description: 'true=附上服务探测结果与一条原始会话记录（排查用，默认 false）' },
+    full: { type: 'boolean', description: 'true=显示完整 session id 与血缘（parentSession/origin/depth），编排用（默认 false=精简）' },
+  },
+
+  async run(args = {}, env = {}) {
+    const ctx = env?.ctx ?? null;
+    const root = ctx && typeof ctx === 'object' && ctx.root ? ctx.root : ctx;
+    if (!root || typeof root.get !== 'function') {
+      return { ok: false, msg: '拿不到宿主 ctx（env.ctx 缺失或没有 .get）—— 本工具需要 expose:\'all\' 才能在跨通道环境里拿到宿主句柄' };
+    }
+
+    const limit = Math.max(1, Math.min(50, Number(args?.limit) > 0 ? Math.floor(Number(args.limit)) : 10));
+    const filter = String(args?.workspace ?? '').trim().toLowerCase();
+    const lines = [];
+    const notes = [];
+
+    // ── 服务探测（如实报出可用性，缺了也能看出原因）──
+    const probe = {};
+    for (const n of PROBE) {
+      const s = safeGet(root, n);
+      probe[n] = s === undefined || s === null ? null : typeof s;
+    }
+    const reg = safeGet(root, WORKSPACE_SERVICE);
+    const sq = safeGet(root, SESSION_SERVICE);
+
+    // ── ① 工作区列表 ──
+    let projects = [];
+    if (reg && typeof reg.list === 'function') {
+      try { projects = reg.list() || []; } catch (e) { notes.push('workspaceRegistry.list() 抛错: ' + (e?.message ?? e)); }
+    } else if (!reg) {
+      notes.push(`宿主没挂 ${WORKSPACE_SERVICE} 服务（工作区分组不可用）`);
+    }
+    if (!Array.isArray(projects)) projects = [];
+
+    // ── ② 会话列表（sessionQuery 优先）──
+    let sessions = [];
+    if (sq && typeof sq.listSessions === 'function') {
+      try { sessions = (await sq.listSessions()) || []; } catch (e) { notes.push('sessionQuery.listSessions() 抛错: ' + (e?.message ?? e)); }
+    } else if (!sq) {
+      notes.push(`宿主没挂 ${SESSION_SERVICE} 服务（会话查询不可用）`);
+    }
+    if (!Array.isArray(sessions)) sessions = [];
+
+    // 会话按"最新活跃"排序：优先 lastActivity / updatedAt / 创建时间，取不到的排最后
+    const timeOf = (s) => {
+      const t = pick(s, ['lastActivity', 'lastActivityAt', 'updatedAt', 'lastMessageAt', 'createdAt', 'createdAtMs', 'timestamp', 'startedAt']);
+      const d = t instanceof Date ? t : new Date(typeof t === 'number' ? t : String(t ?? ''));
+      return Number.isNaN(d.getTime()) ? 0 : d.getTime();
+    };
+    sessions.sort((a, b) => timeOf(b) - timeOf(a));
+
+    // 归属：一个会话只归给它 cwd 最长的那个工作区（否则父目录会把子目录工作区的会话一起列走）
+    const owners = new Map();
+    for (const s of sessions) {
+      const cwd = String(pick(s, ['cwd', 'workdir', 'directory', 'workingDirectory']) ?? '');
+      if (!cwd) continue;
+      let best = null;
+      for (const p of projects) {
+        const pd = String(pick(p, ['path', 'directory', 'dir', 'cwd']) ?? '');
+        if (!pd) continue;
+        if (cwd === pd) { const hit = pd.length + 10000; if (!best || hit > best.len) best = { len: hit, p }; continue; }
+        if (cwd.startsWith(pd + '\\') || cwd.startsWith(pd + '/')) { const hit = pd.length; if (!best || hit > best.len) best = { len: hit, p }; }
+      }
+      if (best) owners.set(s, best.p);
+    }
+
+    const full = !!args?.full;
+    const line = (s) => {
+      const id = String(pick(s, ['id', 'sessionId', 'sid']) ?? '?');
+      const title = String(pick(s, ['title', 'name', 'summary']) ?? '').slice(0, 40);
+      const live = pick(s, ['live', 'isLive']) ? 'live' : 'persisted';
+      const t = fmtTime(pick(s, ['lastActivity', 'lastActivityAt', 'updatedAt', 'createdAt', 'createdAtMs', 'startedAt']));
+      const short = id.length > 14 && !full ? id.slice(0, 8) + '…' + id.slice(-4) : id;
+      // 血缘（子代理实测建议：跨会话编排必须看到 parent/origin/depth，否则只能另开 debug 手工比对）
+      const origin = pick(s, ['origin']) ?? '';
+      const depth = pick(s, ['delegationDepth']);
+      const parent = String(pick(s, ['parentSession']) ?? '');
+      const lin = origin
+        ? `  origin=${origin}${depth !== undefined ? ' depth=' + depth : ''}${parent ? ' parent=' + (full ? parent : parent.slice(0, 8) + '…') : ''}`
+        : '';
+      return `   · ${t || '        '}  [${live}]  ${short}${title ? '  ' + title : ''}${lin}`;
+    };
+
+    // 有 workspaceRegistry 就按"目录 → 它的会话"分组；否则退化成一张平表
+    if (projects.length) {
+      for (const p of projects) {
+        const ptitle = String(pick(p, ['title', 'name']) ?? '(未命名)');
+        const pdir = String(pick(p, ['path', 'directory', 'dir', 'cwd']) ?? '');
+        if (filter && !(ptitle.toLowerCase().includes(filter) || pdir.toLowerCase().includes(filter))) continue;
+        const mine = sessions.filter((s) => owners.get(s) === p);
+        lines.push(`${ptitle}${pdir ? '  (' + pdir + ')' : ''}   —— ${mine.length} 个会话`);
+        if (!mine.length) lines.push('   · (这个工作区下没有可列的会话)');
+        for (const s of mine.slice(0, limit)) lines.push(line(s));
+        if (mine.length > limit) lines.push(`   … 还有 ${mine.length - limit} 个（用 limit 调整）`);
+      }
+      // 不属于任何工作区的会话
+      const ungrouped = sessions.filter((s) => !owners.get(s));
+      if (ungrouped.length && !filter) {
+        lines.push(`(不属于任何工作区的会话)   —— ${ungrouped.length} 个`);
+        for (const s of ungrouped.slice(0, limit)) lines.push(line(s));
+      }
+    } else {
+      lines.push(`（工作区分组不可用，退化成会话平表）共 ${sessions.length} 个`);
+      for (const s of sessions.slice(0, limit)) lines.push(line(s));
+    }
+
+    // 注（2026-10-12 主人定）：**不再**在首行显示"我 / 父代"。
+    // 会话来源改用另一条更直接的约定：**模拟用户消息的首行直接给出源会话 id**
+    // （见 session_send 与 lib/session_watch_lib.mjs）。
+    const head = `【DSH 工作区与会话】 工作区 ${projects.length} 个 / 会话 ${sessions.length} 个${filter ? `（筛选: ${args.workspace}）` : ''}`;
+    const tail = notes.length ? '\n' + notes.map((n) => '⚠ ' + n).join('\n') : '';
+    const dbg = args?.debug
+      ? '\n— 服务探测: ' + Object.entries(probe).map(([k, v]) => `${k}=${v ?? '✗'}`).join(', ') +
+        '\n— 首条会话原始结构: ' + JSON.stringify(sessions[0] ?? null).slice(0, 600)
+      : '';
+    return { ok: true, msg: [head, ...lines].join('\n') + tail + dbg };
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaofan/dsh-qqbot",
-  "version": "1.8.4",
+  "version": "1.8.8",
   "description": "QQ Bot IM channel plugin for deepseek-harness (dsh)",
   "type": "module",
   "main": "./entry.js",

package/settings-host.js

@@ -4,7 +4,7 @@
  * 仅 web profile 装配; 同源 fence 抄 modsearch。
  */
 import { readFileSync, writeFileSync, appendFileSync, rmSync, mkdirSync, existsSync, readdirSync, statSync, cpSync, renameSync, openSync, readSync, closeSync, createWriteStream } from 'node:fs';
-import { extname, join, resolve, dirname, normalize, sep } from 'node:path';
+import { basename, extname, join, resolve, dirname, normalize, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from 'node:child_process';
 import { homedir } from 'node:os';
@@ -225,10 +225,25 @@ const OWN_SETTINGS_DIR = join(DSH_HOME_DIR, 'qqbot-settings');
  *   新布局 `{DSH_HOME}/qqbot-settings/<profile>/<ns>.json` —— 各 profile 各一份，**同一个 ns 也不再互相覆盖**；
  *   老布局 `{DSH_HOME}/qqbot-settings/<ns>.json`            —— 所有 profile 共用（就是本次踩坑的根源），仅作读取兜底。
  * 读：新路径优先 → 老路径兜底（老数据不丢）；写：一律写新路径 —— 读取已兜底到老文件，首次保存天然是
- * "老内容 + 本次改动"，等于**自动搬家**。profile 取自 `DSH_PROFILE`；取不到时落 `_default`
- * （退化回老行为，此时由写入者指纹兜底拦住互相覆盖）。
+ * "老内容 + 本次改动"，等于**自动搬家**。
+ *
+ * ⚠️ profile 名（2026-10-12 修）：**不能只读 `process.env.DSH_PROFILE`**。宿主不会把 profile 名放进
+ * 自己的环境变量 —— DSH 是通过 `ctx.get('profileContext').name` 提供的，`DSH_PROFILE` 只在
+ * **每次 shell / 工具调用**时由 harness 临时注入（见 `@deepseek-ai/dsh-shell-env`）。于是这里永远拿到空
+ * → 永远落 `_default/`，"各 profile 各一份"形同虚设（实测 `writer.json` 记的是 `"profile": "unknown"`）。
+ * 现在与 `src/shared/utils.ts` 的 `resolveProfileName()` **同规则**：环境变量 → `PROFILE_ROOT` 目录名
+ * （要求其父目录名为 `profiles`，挡住源码 checkout 目录）→ 落 `_default`。改一处务必同步另一处。
  */
-const NS_PROFILE_DIR = String(process.env.DSH_PROFILE || '').trim().replace(/[^A-Za-z0-9_-]/g, '_') || '_default';
+function resolveProfileName() {
+  const env = String(process.env.DSH_PROFILE || '').trim();
+  if (env) return env;
+  try {
+    return basename(dirname(PROFILE_ROOT)) === 'profiles' ? basename(PROFILE_ROOT) : '';
+  } catch {
+    return '';
+  }
+}
+const NS_PROFILE_DIR = String(resolveProfileName()).trim().replace(/[^A-Za-z0-9_-]/g, '_') || '_default';
 function safeNsOf(ns) {
   return String(ns || NS).replace(/[^A-Za-z0-9_-]/g, '_') || 'im-qqbot';
 }
@@ -274,7 +289,9 @@ function readNsWriter(ns) {
   } catch { return null; }
 }
 function myProfileName() {
-  return String(process.env.DSH_PROFILE || '').trim() || 'unknown';
+  // 2026-10-12：改用 resolveProfileName()（同规则见其定义处注释）——
+  // 原来只读 process.env.DSH_PROFILE，宿主里永远是空 → 指纹恒为 "unknown" → NS_CONFLICT 拦截永久失效。
+  return resolveProfileName() || 'unknown';
 }
 /** 该设置槽是否正被**别的** profile 占用（供 /read 与 /update 共用） */
 function nsConflictOf(ns) {