ds-bot 0.1.3 → 0.1.5

package/src/host/roster.js

@@ -21,13 +21,16 @@ export function install(rt) {
     return workspace.id
   }
 
-  async function createSession(title) {
+  // `dir` is a working folder outside the team workspace. Such a Session is made by cwd
+  // alone, so it joins no DSH workspace and the user's own project lists stay as they are.
+  async function createSession(title, { dir } = {}) {
     // A Bot's tools run here too; while another dsh holds the team, a new Session would
     // belong to no saved Bot.
     const readOnly = rt.readOnly()
     if (readOnly !== undefined) throw new Error(readOnly)
-    const workspaceId = await ensureWorkspace()
-    const { sessionId } = await ctx.sessionController.create({ workspaceId })
+    const usable = dir !== undefined && await rt.isFolder(dir)
+    if (dir !== undefined && !usable) rt.warn('ds-bot: the working folder %s is gone; %s starts in the team workspace', dir, title)
+    const { sessionId } = await ctx.sessionController.create(usable ? { cwd: dir } : { workspaceId: await ensureWorkspace() })
     const agent = await rt.resolveAgent(sessionId)
     await ctx.sessionTitle.rename(agent.session, title)
     return sessionId
@@ -55,7 +58,7 @@ export function install(rt) {
 
   // `pickModel` leaves the model to the user: the chat opens on a model card, and the
   // greeting waits until a model is chosen. So does a Bot made when no model is served.
-  async function createBot({ name: botName, role = '', instructions = '', color, brief = '', createdBy, main = false, avatar, model, effort, copyOf, pickModel = false }) {
+  async function createBot({ name: botName, role = '', instructions = '', color, brief = '', createdBy, main = false, avatar, model, effort, workDir, copyOf, pickModel = false }) {
     const cleanName = String(botName ?? '').trim().slice(0, 40)
     const problem = nameProblem(cleanName)
     if (problem !== undefined) throw new Error(problem)
@@ -64,7 +67,8 @@ export function install(rt) {
     // The model is fixed at creation, so a later change of the DSH default leaves it alone.
     const modelRef = model ? await rt.resolveModel(model) : pickModel ? undefined : await rt.defaultModel()
     const effortId = modelRef !== undefined && effort !== undefined ? await rt.resolveEffort(modelRef, effort) : undefined
-    const id = await createSession(cleanName)
+    const dir = workDir === undefined || workDir === null ? undefined : await rt.cleanWorkDir(workDir)
+    const id = await createSession(cleanName, { dir })
     try {
       state.bots[id] = {
         id,
@@ -75,24 +79,29 @@ export function install(rt) {
         ...(cleanAvatarValue ? { avatar: cleanAvatarValue } : {}),
         ...(modelRef ? { model: modelRef } : {}),
         ...(effortId ? { effort: effortId } : {}),
+        ...(dir ? { workDir: dir } : {}),
         instructions: String(instructions).trim(),
         createdAt: Date.now(),
         createdBy: createdBy ?? null,
+        capabilities: [],
       }
       if (main) state.mainBotIds.push(id)
       const creator = rt.botOf(createdBy)
       const original = rt.botOf(copyOf)
       const language = rt.uiLanguage?.()
+      // The kickoff arrives as a user message, so it outranks the Bot's instructions
+      // unless it gives way to them, and it names no tool those instructions may rule out.
       const kickoff = main
-        ? `You were just set up as the user's Main Bot. Greet the user in one or two short messages: say you will run their Bot team and that they can come to you for anything that needs a decision. Then use ask_user to ask what they want the team to help with first (3-4 short options). Write in ${language ?? 'the user\'s language if known; otherwise Chinese'}.`
+        ? `You were just set up as the user's Main Bot. Greet the user in one or two short messages: say you will run their Bot team and that they can come to you for anything that needs a decision. Then ask in one short question what they want the team to help with first. Write in ${language ?? 'the user\'s language if known; otherwise Chinese'}.`
         : original
-          ? `The user just made you as a copy of ${original.name}: same job, fresh memory. Greet the user in one short message, then use ask_user to ask what this copy should focus on (3-4 short options).`
+          ? `The user just made you as a copy of ${original.name}: same job, fresh memory. Greet the user in one short message, then ask in one short question what this copy should focus on.`
           : creator
-            ? `${creator.name} just created you for the user.${brief ? ` Why you exist: ${brief}` : ''}\nGreet the user in one short message, then use ask_user to ask where to start (3-4 short options relevant to your role, with allowCustom). Keep it brief.`
+            ? `${creator.name} just created you for the user.${brief ? ` Why you exist: ${brief}` : ''}\nGreet the user in one short message, then ask in one short question where to start. Keep it brief.`
             : brief
               ? `The user just created you and sent this first message:\n\n${brief}\n\nIntroduce yourself in one short line, then help with it.`
-              : 'The user just created you. Greet the user in one short message, then use ask_user to ask what you should focus on (3-4 short options, with allowCustom).'
-      const text = !main && language ? `${kickoff}\nWrite in ${language}.` : kickoff
+              : 'The user just created you. Greet the user in one short message, then ask in one short question what you should focus on.'
+      const opener = `${kickoff}\nWhere your instructions say otherwise, follow them.`
+      const text = !main && language ? `${opener}\nWrite in ${language}.` : opener
       const bot = state.bots[id]
       if (modelRef === undefined) {
         bot.kickoff = { text, from: createdBy ?? null, ...(main ? { main: true } : {}) }
@@ -144,6 +153,8 @@ export function install(rt) {
       avatar: bot.avatar,
       model: served ? bot.model : undefined,
       effort: served ? bot.effort : undefined,
+      // A folder that went away since leaves the copy in the team workspace.
+      workDir: bot.workDir !== undefined && await rt.isFolder(bot.workDir) ? bot.workDir : undefined,
       copyOf: bot.id,
     })
   }
@@ -151,6 +162,9 @@ export function install(rt) {
   async function updateBot(id, patch) {
     const bot = rt.botOf(id)
     if (bot === undefined) throw new Error('Unknown Bot')
+    // Checked first, so a folder that does not pass leaves the rest unchanged too.
+    const moving = patch.workDir !== undefined
+    const workDir = moving ? await rt.cleanWorkDir(patch.workDir ?? '') : undefined
     if (patch.name !== undefined) {
       const next = String(patch.name).trim().slice(0, 40)
       const clash = rt.findBot(next)
@@ -190,8 +204,14 @@ export function install(rt) {
       modelChanged = true
     }
     if (patch.permission !== undefined) await rt.setPermission(bot, patch.permission)
+    const moved = moving && workDir !== bot.workDir
+    if (moving) {
+      if (workDir === undefined) delete bot.workDir
+      else bot.workDir = workDir
+    }
     await rt.save()
     if (modelChanged) await rt.applyModel(bot, { force: true })
+    if (moved) void rt.followFolder(bot.id)
     if (bot.model && bot.kickoff !== undefined) {
       const held = bot.kickoff
       delete bot.kickoff
@@ -259,6 +279,8 @@ export function install(rt) {
     if (adminId !== null && !members.includes(adminId)) throw new Error('The admin must be a member of the group')
     if (mode !== undefined && !ROOM_MODES.includes(mode)) throw new Error(`Reply mode must be one of ${ROOM_MODES.join(', ')}`)
     const title = custom || autoRoomName(members)
+    // The group's own Session only relays, so it stays in the team workspace; the
+    // group's folder is for its members' Sessions.
     const id = await createSession(title)
     try {
       state.rooms[id] = {
@@ -308,6 +330,9 @@ export function install(rt) {
     if (patch.mode !== undefined && !ROOM_MODES.includes(patch.mode)) throw new Error(`Reply mode must be one of ${ROOM_MODES.join(', ')}`)
     const name = patch.name === undefined ? undefined : cleanRoomName(patch.name, room.id)
     const notice = patch.notice === undefined ? undefined : cleanNotice(patch.notice)
+    const moving = patch.workDir !== undefined
+    if (moving && byAdmin) throw new Error(`Only the user or a Main Bot can set the folder of "${room.name}"`)
+    const workDir = moving ? await rt.cleanWorkDir(patch.workDir ?? '') : undefined
 
     const changes = []
     const names = ids => ids.map(member => rt.botOf(member)?.name).filter(Boolean).join(', ')
@@ -331,6 +356,12 @@ export function install(rt) {
       room.notice = notice
       changes.push(notice ? 'updated the notice' : 'cleared the notice')
     }
+    // Members' group conversations move on to the folder at their next turn there.
+    if (moving && workDir !== room.workDir) {
+      if (workDir === undefined) delete room.workDir
+      else room.workDir = workDir
+      changes.push(workDir ? `every member now works in ${workDir} here` : 'every member works in its own folder again')
+    }
     const before = room.name
     if (name !== undefined) {
       if (name !== '') {

package/src/host/secrets.js

@@ -526,5 +526,13 @@ export function install(rt) {
     return () => { if (usedTimer !== null) clearTimeout(usedTimer) }
   }, 'ds-bot: load secrets')
 
-  Object.assign(rt, { secretsView, secretValue: name => secrets.get(name)?.value, secretEndpoint, forgetBotSecrets, loadSecrets, redactSecrets: text => redact(text) })
+  Object.assign(rt, {
+    secretsView,
+    secretValue: name => secrets.get(name)?.value,
+    canUseSecret: (name, botId) => canUse(secrets.get(name), botId),
+    secretEndpoint,
+    forgetBotSecrets,
+    loadSecrets,
+    redactSecrets: text => redact(text),
+  })
 }

package/src/host/store.js

@@ -11,8 +11,8 @@ import { currentColor, normalize, unquote } from './text.js'
 export function install(rt) {
   const { ctx, home, statePath } = rt
 
-  /** @type {{version:1, workspaceId?:string, mainBotIds:string[], bots:Record<string,any>, rooms:Record<string,any>, agents:Record<string,any>, exchanges:any[], exchangeTurns:Record<string,number[]>, revision:number}} */
-  const state = { version: 1, mainBotIds: [], bots: {}, rooms: {}, agents: {}, exchanges: [], exchangeTurns: {}, questions: {}, prefs: {}, revision: 0 }
+  /** @type {{version:1, workspaceId?:string, mainBotIds:string[], bots:Record<string,any>, rooms:Record<string,any>, agents:Record<string,any>, capabilities:{items:Record<string,any>}, exchanges:any[], exchangeTurns:Record<string,number[]>, revision:number}} */
+  const state = { version: 1, mainBotIds: [], bots: {}, rooms: {}, agents: {}, capabilities: { items: {} }, exchanges: [], exchangeTurns: {}, questions: {}, prefs: {}, revision: 0 }
   let loaded = null
   let writing = Promise.resolve()
   const { warn } = rt
@@ -97,13 +97,25 @@ export function install(rt) {
   // Fill `state` from the saved file and bring an older team up to date. Returns the
   // groups whose Session titles still need the new name.
   const adopt = (parsed) => {
+    const hadCapabilities = parsed !== null && parsed !== undefined && Object.hasOwn(parsed, 'capabilities')
     for (const key of Object.keys(state)) delete state[key]
     Object.assign(state, JSON.parse(EMPTY), parsed ?? {})
     state.prefs ??= {}
     // Teams saved before the DSH Agent existed carry no `agents`; corrupt values reset.
     if (state.agents === null || typeof state.agents !== 'object' || Array.isArray(state.agents)) state.agents = {}
-    let migrated = false
+    let migrated = !hadCapabilities
+    if (state.capabilities === null || typeof state.capabilities !== 'object' || Array.isArray(state.capabilities)) {
+      state.capabilities = { items: {} }
+      migrated = true
+    } else if (state.capabilities.items === null || typeof state.capabilities.items !== 'object' || Array.isArray(state.capabilities.items)) {
+      state.capabilities.items = {}
+      migrated = true
+    }
     for (const bot of Object.values(state.bots)) {
+      if (!Array.isArray(bot.capabilities)) {
+        bot.capabilities = []
+        migrated = true
+      }
       if (bot.color !== currentColor(bot.color)) {
         bot.color = currentColor(bot.color)
         migrated = true
@@ -248,6 +260,7 @@ export function install(rt) {
         ensureLock()
         await rename(temp, statePath)
         seen = stamp()
+        rt.capabilitiesStateSaved?.()
       } catch (error) {
         await unlink(temp).catch(() => {})
         throw error

package/src/host/tools.js

@@ -2,21 +2,27 @@
 // question card. Group rounds and reading chats are in groups.js.
 import { randomUUID } from 'node:crypto'
 import { defineTool } from '@deepseek-ai/dsh-tools'
-import { COLORS, EXTRA_COLORS, MAX_HOPS, ROOM_BOT_ROUNDS, ROOM_MODES } from './constants.js'
+import { COLORS, EXTRA_COLORS, MAX_HOPS, MAX_UNREAD_REQUESTS, ROOM_BOT_ROUNDS, ROOM_MODES, SOURCE_KIND } from './constants.js'
 import { unquote } from './text.js'
 
 export const output = { schema: { type: 'string' }, render: (_args, value) => [{ type: 'text', text: String(value) }] }
 export const GROUP_REF = { type: 'string', required: true, description: 'Exact group chat name from list_bots' }
+const BLOCKING_QUESTION_TOOL = 'ask_user_question'
 const MODE_PARAM = {
   type: 'string',
   enum: ROOM_MODES,
   description: '"everyone": every member answers a plain message in turn, admin first. "admin" (the default): a plain message goes to the admin, who calls others with @Name. @mentions always choose who answers.',
 }
+const WORK_DIR_PARAM = { type: 'string', description: 'Full path of the folder to work in, where commands and file tools start. Only when the user asks for it' }
 
 export function install(rt) {
   const { ctx, state } = rt
 
   const callerBot = (exec) => rt.botOf(rt.selfOf(exec.agent?.id))
+  const callerRoom = (exec) => {
+    const roomId = rt.groupOwners.get(exec.agent?.id)?.roomId
+    return roomId ? { fromRoomId: roomId } : {}
+  }
 
   const roomLine = (room, self) => {
     const members = room.members.map(rt.botOf).filter(Boolean)
@@ -25,6 +31,7 @@ export function install(rt) {
       `members: ${members.join(', ')}`,
       room.mode === 'admin' && room.admin ? 'plain messages go to the admin first' : 'every member replies in turn',
       room.notice ? `notice: ${room.notice.split('\n')[0].slice(0, 100)}` : '',
+      room.workDir ? `members work in ${room.workDir} here` : '',
     ].filter(Boolean)
     return `- "${room.name}" — ${parts.join('; ')}`
   }
@@ -41,7 +48,7 @@ export function install(rt) {
       const self = rt.selfOf(exec.agent?.id)
       const lines = Object.values(state.bots).map(bot => {
         const model = bot.appliedModel ?? bot.model
-        const tags = [bot.role, model ? `model ${model}` : '', rt.isMain(bot.id) ? 'Main Bot' : '', bot.id === self ? 'you' : ''].filter(Boolean).join(', ')
+        const tags = [bot.role, model ? `model ${model}` : '', bot.workDir ? `works in ${bot.workDir}` : '', rt.isMain(bot.id) ? 'Main Bot' : '', bot.id === self ? 'you' : ''].filter(Boolean).join(', ')
         const job = bot.instructions ? ` — ${bot.instructions.split('\n')[0].slice(0, 120)}` : ''
         return `- ${bot.name}${tags ? ` (${tags})` : ''}${job}`
       })
@@ -68,6 +75,12 @@ export function install(rt) {
     const room = rt.roomOf(rt.groupOwners.get(sessionId)?.roomId)
     return room ? `group "${room.name}"` : 'its own chat'
   }
+  // Delivered but not read yet: no step or turn has taken them out of the inbox.
+  const unreadRequests = agent => [...(agent.inbox?.nextStep ?? []), ...(agent.inbox?.nextTurn ?? [])]
+    .filter(message => message.source?.kind === SOURCE_KIND && message.source.role === 'request').length
+
+  // A tool that throws shows as failed in the chat, instead of as sent or stopped.
+  const refuse = (message) => { throw new Error(message) }
 
   ctx.tools.register(defineTool({
     name: 'message_bot',
@@ -97,10 +110,15 @@ export function install(rt) {
       const turn = rt.live.get(exec.agent?.id)
       const hop = Math.max(turn?.info?.hop ?? 0, ...(turn?.joined ?? []).map(joined => joined.info?.hop ?? 0))
       if (hop >= MAX_HOPS) return 'This chain of Bot messages is already long. Stop here and report to the user instead.'
+      const chat = rt.chatOf(target.id)
+      const unread = unreadRequests(await rt.resolveAgent(chat))
+      if (unread >= MAX_UNREAD_REQUESTS) {
+        refuse(`Not sent: ${target.name} has not read the last ${unread} messages from Bots yet, so it is most likely stuck, for example waiting for the user. Do not send it more; tell the user that ${target.name} is not responding.`)
+      }
       const toUser = args.reply_to === 'user'
-      const working = rt.live.get(rt.chatOf(target.id))?.turn !== undefined
+      const working = rt.live.get(chat)?.turn !== undefined
       const steer = args.when !== 'queue' && !toUser
-      await rt.deliver({ fromId: sender.id, toId: target.id, text: args.message, role: 'request', hop, steer, ...(toUser ? { audience: 'user' } : {}) })
+      await rt.deliver({ fromId: sender.id, toId: target.id, text: args.message, role: 'request', hop, steer, ...(toUser ? { audience: 'user' } : callerRoom(exec)) })
       const sent = toUser
         ? `Delivered to ${target.name}. It will answer the user in its own chat; nothing comes back to you, so point the user to ${target.name}'s chat instead of relaying.`
         : working && steer
@@ -108,18 +126,20 @@ export function install(rt) {
           : working
             ? `Queued for ${target.name}: it reads your message after its current work. Its reply will arrive later as a new message; do not wait for it.`
             : `Delivered to ${target.name}. Its reply will arrive later as a new message; do not wait for it.`
+      // "Delivered" only means it is in the inbox; say so when it may sit there a while.
+      const notes = [
+        rt.waitsForApproval?.(chat) ? `${target.name} is waiting for the user's approval, so it reads your message only after the user answers.` : '',
+        unread > 0 ? `${target.name} has not read ${unread === 1 ? 'an earlier message' : `${unread} earlier messages`} from Bots yet.` : '',
+      ].filter(Boolean)
+      const status = notes.length === 0 ? sent : `${sent} ${notes.join(' ')}`
       // Messages reach a Bot's own chat only; work in a group goes on without them.
-      const groups = activeSessions(target.id).running.filter(sessionId => sessionId !== rt.chatOf(target.id))
-      if (groups.length === 0) return sent
+      const groups = activeSessions(target.id).running.filter(sessionId => sessionId !== chat)
+      if (groups.length === 0) return status
       const stop = rt.isMain(sender.id) ? ' If it must not go on there, use stop_bot.' : ''
-      return `${sent} ${target.name} is also working in ${groups.map(whereOf).join(' and ')}; your message does not reach that work.${stop}`
+      return `${status} ${target.name} is also working in ${groups.map(whereOf).join(' and ')}; your message does not reach that work.${stop}`
     },
   }))
 
-  // stop_bot throws when it does nothing, so the chat shows the call as failed
-  // instead of "Stopped".
-  const refuse = (message) => { throw new Error(message) }
-
   ctx.tools.register(defineTool({
     name: 'stop_bot',
     description: 'Main Bot only. Stop another Bot\'s running turn immediately — when it must not finish a dangerous action and a message_bot warning is not enough. Its queued messages are dropped with the turn. It is then told why in a new turn, whose reply comes back to you.',
@@ -142,7 +162,7 @@ export function install(rt) {
         agent.cancel({ kind: 'hook', reason: 'ds-bot/stopped' })
       }
       const why = String(args.reason ?? '').trim() || 'Stop what you are doing; the previous turn was ended on purpose. Acknowledge briefly.'
-      await rt.deliver({ fromId: sender.id, toId: target.id, text: why, role: 'stopped' })
+      await rt.deliver({ fromId: sender.id, toId: target.id, text: why, role: 'stopped', ...callerRoom(exec) })
       return `Stopped ${target.name} in ${running.map(whereOf).join(' and ')}. It is told why in a new turn, whose reply comes back to you.`
     },
   }))
@@ -156,14 +176,18 @@ export function install(rt) {
       instructions: { type: 'string', required: true, description: 'What this Bot is responsible for and how it should work' },
       brief: { type: 'string', description: 'Why the user wants it, passed to the new Bot as its first context' },
       model: { type: 'string', description: 'Model the Bot runs on, as provider/model or a model id. Only when the user names one; otherwise the DSH default model.' },
+      work_dir: WORK_DIR_PARAM,
     },
     output,
     async execute(args, exec) {
       await rt.load()
       if (!rt.isMain(rt.selfOf(exec.agent?.id))) return 'Only the Main Bot can create Bots. Ask the Main Bot instead.'
       try {
-        const bot = await rt.createBot({ ...args, createdBy: rt.selfOf(exec.agent.id) })
-        return `Created ${bot.name}. It is greeting the user now.`
+        const workDir = args.work_dir ? await rt.cleanWorkDir(args.work_dir) : undefined
+        const name = String(args.name ?? '').trim()
+        await rt.approveFolder(exec, { path: workDir, who: { en: `the new Bot ${name}`, zh: `新 Bot ${name} ` } })
+        const bot = await rt.createBot({ ...args, workDir, createdBy: rt.selfOf(exec.agent.id) })
+        return `Created ${bot.name}${workDir ? `, working in ${workDir}` : ''}. It is greeting the user now.`
       } catch (error) {
         return `Could not create the Bot: ${error.message}`
       }
@@ -172,7 +196,7 @@ export function install(rt) {
 
   ctx.tools.register(defineTool({
     name: 'update_bot',
-    description: 'Change a Bot\'s name, role, color, model, or instructions. Every Bot may change itself; only a Main Bot may change another Bot.',
+    description: 'Change a Bot\'s name, role, color, model, working folder, or instructions. Every Bot may change itself; only a Main Bot may change another Bot.',
     parameters: {
       bot: { type: 'string', description: 'Current name of the Bot to change; leave out to change yourself' },
       name: { type: 'string', description: 'New name' },
@@ -180,6 +204,7 @@ export function install(rt) {
       instructions: { type: 'string', description: 'Replacement instructions' },
       color: { type: 'string', description: `One of ${[...COLORS, ...EXTRA_COLORS].join(', ')}` },
       model: { type: 'string', description: 'Move the Bot to another model, as provider/model or a model id' },
+      work_dir: { ...WORK_DIR_PARAM, description: `${WORK_DIR_PARAM.description}; an empty string returns it to the team workspace` },
     },
     output,
     async execute(args, exec) {
@@ -192,8 +217,13 @@ export function install(rt) {
       if (bot.id !== caller.id && !rt.isMain(self)) return 'Only a Main Bot can change another Bot. Leave out bot to change yourself, or ask a Main Bot with message_bot.'
       try {
         const { name: newName, role, instructions, color, model } = args
-        const next = await rt.updateBot(bot.id, { name: newName, role, instructions, color, ...(model ? { model } : {}) })
-        return `Updated ${next.name}.`
+        const moving = typeof args.work_dir === 'string'
+        const workDir = moving ? await rt.cleanWorkDir(args.work_dir) : undefined
+        if (moving && workDir !== bot.workDir) await rt.approveFolder(exec, { path: workDir, sessions: rt.sessionsOfBot(bot.id), who: { en: bot.name, zh: ` ${bot.name} ` } })
+        const next = await rt.updateBot(bot.id, { name: newName, role, instructions, color, ...(model ? { model } : {}), ...(moving ? { workDir: workDir ?? '' } : {}) })
+        if (!moving) return `Updated ${next.name}.`
+        const folder = workDir ?? 'the team workspace'
+        return bot.id === caller.id ? `Updated ${next.name}. From your next step on, you work in ${folder}.` : `Updated ${next.name}. It now works in ${folder}.`
       } catch (error) {
         return `Could not update the Bot: ${error.message}`
       }
@@ -276,6 +306,7 @@ export function install(rt) {
       remove_members: { type: 'array', items: { type: 'string' }, description: 'Exact names of Bots to remove' },
       admin: { type: 'string', description: 'Member to make the admin; "none" leaves the group without one (Main Bots only)' },
       mode: MODE_PARAM,
+      work_dir: { ...WORK_DIR_PARAM, description: `${WORK_DIR_PARAM.description}. Every member works there in this group; an empty string lets each member work in its own folder again (Main Bots only)` },
     },
     output,
     async execute(args, exec) {
@@ -284,6 +315,8 @@ export function install(rt) {
       if (rt.botOf(self) === undefined) return 'Only Bots on the team can use update_group.'
       const { room, error } = pickRoom(args.group, self)
       if (error) return error
+      const moving = typeof args.work_dir === 'string'
+      if (moving && !rt.isMain(self)) return `Only a Main Bot can set the folder of "${room.name}".`
       const add = resolveBots(args.add_members)
       const remove = resolveBots(args.remove_members)
       const unknown = [...add.unknown, ...remove.unknown]
@@ -297,6 +330,16 @@ export function install(rt) {
         }
       }
       try {
+        const workDir = moving ? await rt.cleanWorkDir(args.work_dir) : undefined
+        // A Bot that joins a group with a folder works there from its first turn.
+        const joining = add.bots.filter(bot => !room.members.includes(bot.id))
+        if (moving && workDir !== room.workDir) {
+          const members = [...room.members, ...joining.map(bot => bot.id)]
+          await rt.approveFolder(exec, { path: workDir, sessions: members.map(id => room.sessions?.[id]).filter(Boolean), who: { en: `every member of "${room.name}"`, zh: `群聊「${room.name}」的成员` } })
+        } else if (joining.length > 0) {
+          const names = joining.map(bot => bot.name)
+          await rt.approveFolder(exec, { path: room.workDir, sessions: joining.map(bot => room.sessions?.[bot.id]).filter(Boolean), who: { en: names.join(', '), zh: ` ${names.join('、')} ` } })
+        }
         const { room: next, changes } = await rt.updateRoom(room.id, {
           name: args.name,
           notice: args.notice,
@@ -304,6 +347,7 @@ export function install(rt) {
           admin,
           add: add.bots.map(bot => bot.id),
           remove: remove.bots.map(bot => bot.id),
+          ...(moving ? { workDir: workDir ?? '' } : {}),
         }, self)
         return changes.length === 0 ? `Nothing changed in "${next.name}".` : `Updated "${next.name}": ${changes.join('; ')}.`
       } catch (failure) {
@@ -334,7 +378,7 @@ export function install(rt) {
     description: 'Post a message into a group chat as yourself. It starts a round: members reply in the group, where the user reads them. Main Bots may post into any group; an admin into its own group.',
     parameters: {
       group: GROUP_REF,
-      message: { type: 'string', required: true, description: 'What to say; write "@Name" to choose who answers' },
+      message: { type: 'string', required: true, description: 'What to say; write "@Name" to choose who answers, and a name without "@" to only mention a member' },
       report_back: { type: 'boolean', description: 'Also send the members\' replies back to you as a new message when the round ends' },
     },
     output,
@@ -421,5 +465,135 @@ export function install(rt) {
     },
   }))
 
-  Object.assign(rt, { pickRoom })
+  // dsh's own question tool holds the turn open until the user answers, and every
+  // message from another Bot or a group round queues behind it. Bot Sessions ask
+  // through ask_user instead, so the tool is taken out of their tool list.
+  const hiddenQuestion = new WeakSet()
+  const hideBlockingQuestion = (agent) => {
+    if (agent === undefined || hiddenQuestion.has(agent) || !rt.isBotSession(agent.session?.id)) return
+    if (typeof agent.ctx?.tools?.restrict !== 'function') return
+    try {
+      // restrict() throws on a name this profile does not serve.
+      if (!ctx.tools.schemas(agent).some(schema => schema.name === BLOCKING_QUESTION_TOOL)) return
+      agent.ctx.tools.restrict({ deny: [BLOCKING_QUESTION_TOOL] })
+      hiddenQuestion.add(agent)
+    } catch (error) {
+      rt.warn('ds-bot: %s stays in the tool list of %s: %s', BLOCKING_QUESTION_TOOL, agent.session?.id, error)
+    }
+  }
+  // A new Bot, part, or group Session gets its Agent before ds-bot records it, so the
+  // list is only trimmed once ds-bot resolves that Agent again; the guard refuses
+  // the tool in any Bot Session meanwhile.
+  ctx.tools.guard(exec => (exec.name === BLOCKING_QUESTION_TOOL && rt.isBotSession(exec.agent?.id)
+    ? `Bots cannot use ${BLOCKING_QUESTION_TOOL}. Ask with ask_user in your own chat, or ask in your reply.`
+    : undefined))
+  // Creation waits for this listener, so the Agent's first step already lacks the tool.
+  ctx.on('agent/created', async ({ agent }) => {
+    try {
+      await rt.load()
+      hideBlockingQuestion(agent)
+    } catch (error) {
+      rt.warn('ds-bot: hiding %s on agent/created failed: %s', BLOCKING_QUESTION_TOOL, error)
+    }
+  })
+
+  ctx.tools.register(defineTool({
+    name: 'list_capabilities',
+    description: 'List shared MCP servers, skills, and packs, plus the capabilities attached to you.',
+    parameters: {},
+    output,
+    async execute(_args, exec) {
+      await rt.load()
+      const self = rt.selfOf(exec.agent?.id)
+      const bot = rt.botOf(self)
+      if (!bot) return 'Only Bots on the team can use list_capabilities.'
+      const items = Object.values(state.capabilities?.items ?? {})
+      if (items.length === 0) return 'No shared capabilities are saved yet.'
+      const statuses = rt.capabilityStatusesView()[bot.id] ?? {}
+      const lines = items.map(item => {
+        const extra = item.kind === 'pack' ? `; includes ${(item.items ?? []).join(', ') || 'nothing'}`
+          : item.kind === 'mcp' && item.transport === 'stdio' ? `; ${item.approved ? 'allowed' : 'needs user approval'}` : ''
+        const itemStatus = statuses[item.name]
+        const state = itemStatus ? ` (${itemStatus.state}${itemStatus.error ? `: ${itemStatus.error}` : ''})` : ''
+        const status = bot.capabilities?.includes(item.name) ? `; attached to you${state}` : ''
+        return `- ${item.name} (${item.kind})${item.description ? ` — ${item.description}` : ''}${extra}${status}`
+      })
+      return ['Shared capabilities:', ...lines].join('\n')
+    },
+  }))
+  ctx.tools.register(defineTool({
+    name: 'save_capability',
+    description: 'Create or update a shared MCP server, skill, or pack. Changes apply from your next message.',
+    parameters: {
+      name: { type: 'string', required: true, description: 'Lowercase letters, digits, and single hyphens, up to 32 characters; "github" is reserved' },
+      kind: { type: 'string', required: true, enum: ['mcp', 'skill', 'pack'] },
+      description: { type: 'string', description: 'What this capability provides' },
+      transport: { type: 'string', enum: ['stdio', 'streamable-http'], description: 'How to reach an MCP server: a local command or an HTTP URL' },
+      command: { type: 'string', description: 'Program that starts a local MCP server' },
+      args: { type: 'array', items: { type: 'string' }, description: 'Arguments for command' },
+      env: { type: 'object', additionalProperties: true, description: 'Environment variables for command; write $DSH_SECRET_<NAME> to insert a saved secret instead of the value' },
+      url: { type: 'string', description: 'MCP server URL' },
+      headers: { type: 'object', additionalProperties: true, description: 'HTTP headers; write $DSH_SECRET_<NAME> to insert a saved secret instead of the value' },
+      content: { type: 'string', description: 'Skill instructions' },
+      items: { type: 'array', items: { type: 'string' }, description: 'MCP server and skill names in the pack' },
+    },
+    output,
+    async execute(args, exec) {
+      await rt.load()
+      const self = rt.selfOf(exec.agent?.id)
+      if (!rt.botOf(self)) return 'Only Bots on the team can use save_capability.'
+      try {
+        const item = await rt.capabilitySave(args, { botId: self })
+        const approval = item.kind === 'mcp' && item.transport === 'stdio' && !item.approved
+          ? ' The user must allow this MCP server in DS Bot settings before it can work.'
+          : ''
+        return `Saved ${item.name}. Bots with it attached use the change from their next message.${approval}`
+      } catch (error) { return error.message }
+    },
+  }))
+  ctx.tools.register(defineTool({
+    name: 'delete_capability',
+    description: 'Remove a shared capability and detach it from every Bot and pack.',
+    parameters: { name: { type: 'string', required: true } },
+    output,
+    async execute(args, exec) {
+      await rt.load()
+      const self = rt.selfOf(exec.agent?.id)
+      if (!rt.botOf(self)) return 'Only Bots on the team can use delete_capability.'
+      try {
+        await rt.capabilityDelete(args.name, { botId: self })
+        return `Deleted ${args.name}; it was removed from every Bot and pack. The change applies from their next message.`
+      } catch (error) { return error.message }
+    },
+  }))
+  for (const [name, endpoint, verb] of [['attach_capability', 'attach', 'Attached'], ['detach_capability', 'detach', 'Detached']]) {
+    ctx.tools.register(defineTool({
+      name,
+      description: `${verb} a shared capability to yourself, or to another Bot if you are a Main Bot.`,
+      parameters: {
+        name: { type: 'string', required: true, description: 'Capability name from list_capabilities' },
+        bot: { type: 'string', description: 'Optional Bot name; only a Main Bot may change another Bot' },
+      },
+      output,
+      async execute(args, exec) {
+        await rt.load()
+        const self = rt.selfOf(exec.agent?.id)
+        if (!rt.botOf(self)) return `Only Bots on the team can use ${name}.`
+        try {
+          const result = await rt.changeCapabilityAttachment(endpoint, args, self)
+          const attached = state.capabilities.items[args.name]
+          const members = attached?.kind === 'pack'
+            ? (attached.items ?? []).map(child => state.capabilities.items[child]).filter(Boolean)
+            : attached ? [attached] : []
+          const approvals = members
+            .filter(item => item.kind === 'mcp' && item.transport === 'stdio' && item.approved !== true)
+            .map(item => ` The user must allow ${item.name} in DS Bot settings before it can work.`)
+            .join('')
+          return `${verb} ${args.name} ${args.bot ? `to ${result.bot}` : 'to yourself'}. Changes apply from ${result.bot}'s next message.${endpoint === 'attach' ? approvals : ''}`
+        } catch (error) { return error.message }
+      },
+    }))
+  }
+
+  Object.assign(rt, { pickRoom, hideBlockingQuestion })
 }