ds-bot 0.1.0 → 0.1.2

package/index.js

@@ -6,6 +6,7 @@ import { join } from 'node:path'
 import * as diagnostics from './src/host/diagnostics.js'
 import * as store from './src/host/store.js'
 import * as models from './src/host/models.js'
+import * as permissions from './src/host/permissions.js'
 import * as turns from './src/host/turns.js'
 import * as delivery from './src/host/delivery.js'
 import * as roster from './src/host/roster.js'
@@ -23,6 +24,7 @@ import * as connectors from './src/host/connectors.js'
 import * as schedules from './src/host/schedules.js'
 import * as usage from './src/host/usage.js'
 import * as update from './src/host/update.js'
+import * as dshUpdate from './src/host/dsh-update.js'
 import * as channel from './src/host/channel.js'
 
 export { COLORS } from './src/host/constants.js'
@@ -34,7 +36,7 @@ export const inject = ['llm', 'tools', 'systemPrompt', 'sessionController', 'ses
 // the functions other modules call; they call them through `rt` at run time, never during
 // install. Listeners run and tools are listed in registration order, so this order holds:
 // usage meters model requests after every listener that rewrites them.
-const MODULES = [diagnostics, store, models, turns, delivery, roster, agents, prompt, tools, chatIndex, groups, memory, parts, images, secrets, connectors, schedules, browser, usage, update, channel]
+const MODULES = [diagnostics, store, models, permissions, turns, delivery, roster, agents, prompt, tools, chatIndex, groups, memory, parts, images, secrets, connectors, schedules, browser, usage, update, dshUpdate, channel]
 
 export function apply(ctx, config = {}) {
   const home = config.home ?? join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'bot')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ds-bot",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "DS Bot: a team of long-lived Bots for DeepSeek Harness, with Main Bots, Bot-to-Bot messages and group chats",
   "keywords": [
     "dsh-plugin",

package/src/host/channel.js

@@ -27,7 +27,7 @@ export function install(rt) {
   const fail = (message, code = 'bot/error') => ({ ok: false, error: { code, message, details: {} } })
   // Models come from DSH, not state.json, so a provider added in Harness settings
   // changes the view without a new revision.
-  const modelsKey = () => `${rt.cachedCatalog().map(entry => entry.ref).join(',')}|${rt.cachedDefault() ?? ''}`
+  const modelsKey = () => `${rt.cachedCatalog().map(entry => entry.reasoning ? `${entry.ref}:${JSON.stringify(entry.reasoning)}` : entry.ref).join(',')}|${rt.cachedDefault() ?? ''}`
   const view = () => ({
     revision: state.revision,
     workspaceId: state.workspaceId ?? null,
@@ -55,6 +55,7 @@ export function install(rt) {
     colors: [...COLORS, ...EXTRA_COLORS],
     models: rt.cachedCatalog(),
     defaultModel: rt.cachedDefault() ?? null,
+    permissions: rt.permissionCatalog?.() ?? null,
     modelsKey: modelsKey(),
     prefs: state.prefs,
     // Whether a Desktop window should serve Bot browser reads (see browser.js).
@@ -70,7 +71,7 @@ export function install(rt) {
   const live = () => ({ activity: rt.activityView(), memoryNews: rt.memoryNews(), memoryReviews: rt.memoryReviews(), connectors: rt.connectorsView() })
   // What a host that only reads the team may still answer.
   // Updates change the dsh profile, not the team, so a reading host may run them too.
-  const READS = new Set(['state', 'models', 'earlier', 'room-progress', 'exchange', 'usage', 'schedules', 'memory-view', 'browser-wait', 'browser-result', 'diagnostics', 'diagnostics-log', 'diagnostics-clear', 'update-check', 'update-install'])
+  const READS = new Set(['state', 'models', 'efforts', 'earlier', 'room-progress', 'exchange', 'usage', 'schedules', 'memory-view', 'browser-wait', 'browser-result', 'diagnostics', 'diagnostics-log', 'diagnostics-clear', 'update-check', 'update-install', 'dsh-update-install', 'repo-stars'])
 
   function setPrefs(body) {
     if (body.theme !== undefined) {
@@ -107,6 +108,8 @@ export function install(rt) {
         case 'models':
           await rt.catalog({ fresh: true })
           return ok({ modelsKey: modelsKey() })
+        case 'efforts':
+          return ok(await rt.reasoningOf(String(body.ref ?? '')) ?? { efforts: [] })
         case 'duplicate-bot':
           await rt.load()
           return ok(await rt.duplicateBot(body.id))
@@ -129,7 +132,7 @@ export function install(rt) {
           return ok([...rt.roomProgress.entries()].filter(([, entry]) => entry.roomId === body.roomId).map(([callId, entry]) => ({ callId, replies: entry.replies, speaking: entry.speaking ?? null })))
         case 'create-bot': {
           await rt.bootstrap()
-          const bot = await rt.createBot({ name: body.name, role: body.role, color: body.color, instructions: body.instructions, brief: body.brief, avatar: body.avatar, model: body.model })
+          const bot = await rt.createBot({ name: body.name, role: body.role, color: body.color, instructions: body.instructions, brief: body.brief, avatar: body.avatar, model: body.model, effort: body.effort })
           return ok(bot)
         }
         case 'update-bot':
@@ -259,10 +262,16 @@ export function install(rt) {
           }, AbortSignal.timeout(30_000))
           return ok(true)
         }
-        case 'update-check':
-          return ok(await rt.updateCheck({ fresh: body.fresh === true }))
+        case 'update-check': {
+          const fresh = body.fresh === true
+          return ok({ ...(await rt.updateCheck({ fresh })), dsh: (await rt.dshUpdateCheck?.({ fresh })) ?? null })
+        }
         case 'update-install':
           return ok(rt.updateStart())
+        case 'dsh-update-install':
+          return ok(rt.dshUpdateStart?.())
+        case 'repo-stars':
+          return ok(await rt.repoStars())
         // The Desktop window's long poll for read_browser, and its answers.
         case 'browser-wait': {
           if (rt.browserChannel === undefined) return fail('Bot browsers are off on this host', 'bot/browser-off')

package/src/host/dsh-update.js

@@ -0,0 +1,170 @@
+// DSH updates: a released DS Bot may name the DSH release it was verified
+// against (`dsBot.verifiedDsh` in package.json); a release that names none
+// offers nothing. The newest released bot wins: offering that version and
+// nothing newer keeps the update path away from DSH releases we have not
+// checked. A DSH installed from npm swaps with `npm i -g`; a packaged app's
+// runtime lives inside its bundle and only its own updater moves it, to the
+// newest release it finds, so the client offers it only when that release is
+// the verified one.
+import { spawn } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+import {
+  CHECK_TTL_MS, cleanVersion, encodeName, fetchJson, installSpecOf,
+  newer, registryPlan, repoSlug, sourceOf,
+} from './update.js'
+
+const PKG = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'))
+const APP_BOOT = '@deepseek-ai/dsh-app-boot'
+const DSH_PACKAGE = '@deepseek-ai/dsh'
+
+export function install(rt) {
+  const { ctx, config } = rt
+  const enabled = config.updateCheck !== false
+
+  const status = {
+    current: null, verified: null, kind: 'npm', blockedBy: null,
+    checkedAt: 0, phase: 'idle', installed: null, error: null,
+  }
+  let target = null
+  let checking = null
+  let running = null
+
+  // A newer `minBot` than the running bot gates the offer: the bot goes first.
+  const blocked = () => status.blockedBy !== null && newer(status.blockedBy, PKG.version)
+
+  const view = () => ({
+    current: status.current, verified: status.verified, kind: status.kind, blockedBy: status.blockedBy,
+    checkedAt: status.checkedAt, phase: status.phase, installed: status.installed, error: status.error,
+    // Nothing is offered without a current version to compare against.
+    available: status.phase !== 'installed' && target !== null && status.current !== null
+      && status.verified !== null && status.verified !== status.current && !blocked(),
+  })
+
+  // The version of the DSH that is running us: the app-boot export, or — where
+  // that import cannot see it — the nearest @deepseek-ai package.json above the
+  // entry script.
+  async function currentDsh() {
+    try {
+      const loader = ctx.get?.('loader')
+      const loaded = await loader?.import?.(APP_BOOT)
+      const appBoot = loader?.unwrapExports?.(loaded) ?? loaded?.default ?? loaded
+      const version = cleanVersion(appBoot?.getDshRuntimeVersion?.())
+      if (version) return version
+    } catch { /* the export is not visible here: read the install instead */ }
+    let dir = dirname(String(process.argv[1] ?? ''))
+    for (let depth = 0; depth < 12; depth += 1) {
+      try {
+        const manifest = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'))
+        if (manifest?.name?.startsWith?.('@deepseek-ai/')) {
+          const version = cleanVersion(manifest.version)
+          if (version) return version
+        }
+      } catch { /* not a package directory */ }
+      const parent = dirname(dir)
+      if (parent === dir) break
+      dir = parent
+    }
+    return null
+  }
+
+  // A bundled package manager means the runtime came with the app and only the
+  // app's own updater can move it.
+  const installKind = () =>
+    typeof ctx.get?.('profileContext')?.packageManager?.command === 'string' ? 'app' : 'npm'
+
+  // The newest released DS Bot's `dsBot` block, through the same channel the bot
+  // itself updates from: its registry, or the public repo's latest release.
+  async function releasedDeclaration(source) {
+    if (source.kind === 'registry') {
+      for (const registry of await registryPlan(config, ctx.get?.('pluginManager'))) {
+        try {
+          const manifest = await fetchJson(`${registry}${encodeName(PKG.name)}/latest`)
+          if (manifest?.dsBot?.verifiedDsh) return manifest.dsBot
+        } catch { /* unreachable or not published there: ask the next one */ }
+      }
+      return null
+    }
+    const repo = repoSlug()
+    if (!repo) return null
+    try {
+      const release = await fetchJson(`https://api.github.com/repos/${repo}/releases/latest`, { 'user-agent': `${PKG.name}/${PKG.version}` })
+      const tag = cleanVersion(release?.tag_name)
+      if (!tag) return null
+      const manifest = await fetchJson(`https://raw.githubusercontent.com/${repo}/${release.tag_name}/ds-bot/package.json`, { 'user-agent': `${PKG.name}/${PKG.version}` })
+      return manifest?.dsBot?.verifiedDsh ? manifest.dsBot : null
+    } catch { return null }
+  }
+
+  async function runCheck() {
+    try {
+      status.current = await currentDsh()
+      status.kind = installKind()
+      // The release the running package itself verified stays the floor: a bot
+      // older than its own declaration has nothing newer to offer.
+      const declared = [{ verifiedDsh: PKG.dsBot?.verifiedDsh }]
+      const released = await releasedDeclaration(sourceOf(await installSpecOf(ctx)))
+      if (released) declared.push(released)
+      const newestDeclared = declared
+        .filter(entry => cleanVersion(entry.verifiedDsh))
+        .sort((a, b) => (newer(cleanVersion(a.verifiedDsh), cleanVersion(b.verifiedDsh)) ? -1 : 1))[0]
+      status.verified = cleanVersion(newestDeclared?.verifiedDsh)
+      // A release may gate the DSH update on a newer bot: offer nothing until
+      // the bot itself is at least `minBot`.
+      status.blockedBy = cleanVersion(newestDeclared?.minBot)
+      target = status.current !== null && status.verified !== null && status.verified !== status.current
+        ? { version: status.verified }
+        : null
+      status.error = null
+    } catch (error) {
+      rt.warn('ds-bot: dsh update check failed: %s', error?.message ?? error)
+      status.verified = null
+      status.blockedBy = null
+      target = null
+    }
+    status.checkedAt = Date.now()
+  }
+
+  /** Read current and verified DSH versions; a fresh check ignores the last answer. */
+  async function check({ fresh = false } = {}) {
+    if (!enabled) return view()
+    if (checking) return checking
+    if (!fresh && Date.now() - status.checkedAt < CHECK_TTL_MS) return view()
+    checking = runCheck().finally(() => { checking = null })
+    await checking
+    return view()
+  }
+
+  /** Swap an npm-installed DSH for the verified version; the answer comes back through `check`. */
+  function start() {
+    if (status.phase === 'installing') return view()
+    if (target === null || blocked()) throw new Error('No DSH update is available')
+    if (status.kind !== 'npm') throw new Error('This DSH updates with its app')
+    const chosen = target
+    Object.assign(status, { phase: 'installing', error: null })
+    const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm'
+    const args = ['install', '-g', `${DSH_PACKAGE}@${chosen.version}`]
+    const runner = rt.dshSpawn ?? ((command, argv, options) => spawn(command, argv, options))
+    running = runner(npm, args, { windowsHide: true })
+    let output = ''
+    running.stdout?.on?.('data', chunk => { output = `${output}${chunk}`.slice(-4000) })
+    running.stderr?.on?.('data', chunk => { output = `${output}${chunk}`.slice(-4000) })
+    const done = new Promise((resolve, reject) => {
+      running.once?.('error', reject)
+      running.once?.('close', code => (code === 0 ? resolve() : reject(new Error(`npm exited ${code}`))))
+    })
+    void done
+      .then(() => Object.assign(status, { phase: 'installed', installed: chosen.version }))
+      .catch((error) => {
+        rt.warn('ds-bot: dsh update to %s failed: %s', chosen.version, error?.message ?? error)
+        Object.assign(status, { phase: 'failed', error: `${error?.message ?? error}${output ? ` — ${output.trim().slice(-400)}` : ''}`.slice(0, 600) })
+      })
+    return view()
+  }
+
+  // Whatever npm is still running when the plugin unloads dies with it.
+  ctx.effect(() => () => running?.kill?.(), 'ds-bot: dsh update install')
+
+  Object.assign(rt, { dshUpdateCheck: check, dshUpdateStart: start, dshUpdateView: view })
+}

package/src/host/groups.js

@@ -117,6 +117,8 @@ export function install(rt) {
       await rt.selectSessionModel(id, splitRef(ref))
         .catch(error => rt.warn('ds-bot: model for %s in %s not applied: %s', member.name, room.name, error))
     }
+    await rt.applyPermission(member, id)
+      .catch(error => rt.warn('ds-bot: permission for %s in %s not applied: %s', member.name, room.name, error))
     await rt.save()
     return { id, brief: await rt.ownChatBrief(member) }
   }

package/src/host/models.js

@@ -11,10 +11,29 @@ export function install(rt) {
 
   let modelsSynced = null
   let catalogCache = { at: 0, value: [] }
-  ctx.on?.('llm/adapters-updated', () => { catalogCache = { at: 0, value: [] } })
+  // A model's thinking levels, resolved once and kept for a short while: they change
+  // only with the provider, which also drops the catalog cache.
+  const reasoningCache = new Map()
+  ctx.on?.('llm/adapters-updated', () => { catalogCache = { at: 0, value: [] }; reasoningCache.clear() })
+
+  // The thinking levels a model serves: `{efforts: [{id, name, description?}],
+  // defaultEffort?}`, or undefined when it has none or the provider cannot say.
+  async function reasoningOf(ref) {
+    const cached = reasoningCache.get(ref)
+    if (cached !== undefined && Date.now() - cached.at < CATALOG_TTL_MS) return cached.value
+    const route = splitRef(ref)
+    const info = route === undefined ? undefined : await ctx.llm.resolveModelInfo?.(route.provider, route.model).catch(() => undefined)
+    const value = info?.reasoning === undefined ? undefined : {
+      efforts: (info.reasoning.efforts ?? []).map(effort => ({ id: effort.id, name: effort.name ?? effort.id, ...(effort.description ? { description: effort.description } : {}) })),
+      ...(info.reasoning.defaultEffort === undefined ? {} : { defaultEffort: info.reasoning.defaultEffort }),
+    }
+    reasoningCache.set(ref, { at: Date.now(), value })
+    return value
+  }
 
   // A provider's model list can change in DSH settings without any event, so a picker
-  // that is about to be used asks for a `fresh` one.
+  // that is about to be used asks for a `fresh` one. Entries for models a Bot uses
+  // also carry their `reasoning`, so the picker can offer thinking levels.
   async function catalog({ fresh = false } = {}) {
     if (!fresh && Date.now() - catalogCache.at < CATALOG_TTL_MS && catalogCache.value.length > 0) return catalogCache.value
     const entries = []
@@ -32,6 +51,11 @@ export function install(rt) {
         })
       }
     }
+    const used = new Set(Object.values(state.bots ?? {}).flatMap(bot => [bot.model, bot.appliedModel].filter(Boolean)))
+    await Promise.all(entries.filter(entry => used.has(entry.ref)).map(async (entry) => {
+      const reasoning = await reasoningOf(entry.ref)
+      if (reasoning !== undefined) entry.reasoning = reasoning
+    }))
     catalogCache = { at: Date.now(), value: entries }
     return entries
   }
@@ -72,17 +96,43 @@ export function install(rt) {
     return [bot.model, bot.appliedModel].find(ref => ref && served.has(ref)) ?? pickDefault(entries)
   }
 
+  // The thinking level a Bot asked for, when the model it runs on serves it; else the
+  // model's own default applies. A level the model does not have is ignored, never
+  // sent: an explicit effort a provider does not know is a hard refusal there.
+  async function desiredEffort(bot, ref) {
+    if (bot.effort === undefined || ref === undefined) return undefined
+    const reasoning = await reasoningOf(ref)
+    return reasoning?.efforts?.some(effort => effort.id === bot.effort) ? bot.effort : undefined
+  }
+
+  // A thinking level id, or a name only one level of the model has, like resolveModel.
+  async function resolveEffort(ref, text) {
+    const wanted = String(text ?? '').trim()
+    if (wanted === '') return undefined
+    const reasoning = await reasoningOf(ref)
+    const efforts = reasoning?.efforts ?? []
+    if (efforts.length === 0) throw new Error(`Model ${ref} has no thinking levels`)
+    const key = normalize(wanted)
+    const named = efforts.filter(effort => normalize(effort.id) === key || normalize(effort.name) === key)
+    if (named.length === 1) return named[0].id
+    throw new Error(`Thinking level ${wanted} is not available for ${ref}. Available: ${efforts.map(effort => effort.name).join(', ')}`)
+  }
+
   // DSH's selectModel also saves the selection as the profile default model, in the
   // background. A Bot's model is its own, so the user's default is written back after
   // it. Selections run one at a time and wait for the write-back: profile writes land in
   // submission order, so the next one reads the user's default, not a Bot's.
   let selecting = Promise.resolve()
-  function selectSessionModel(sessionId, { provider, model }) {
+  function selectSessionModel(sessionId, { provider, model, reasoningEffort }) {
     const run = selecting.then(async () => {
       const defaults = ctx.get?.('agentDefaultModel')
       const before = defaults?.currentSelection?.()
-      const result = await ctx.sessionController.selectModel({ sessionId, provider, model })
-      if (before?.provider && before?.model && (before.provider !== provider || before.model !== model)) {
+      const result = await ctx.sessionController.selectModel({
+        sessionId, provider, model,
+        ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
+      })
+      const saved = result?.selected ?? { provider, model, ...(reasoningEffort === undefined ? {} : { reasoningEffort }) }
+      if (before?.provider && before?.model && !sameSelection(before, saved)) {
         await defaults.saveSelection(before).catch(error => rt.warn('ds-bot: the default model was not restored: %s', error))
       }
       return result
@@ -91,18 +141,24 @@ export function install(rt) {
     return run
   }
 
+  const sameSelection = (a, b) => a.provider === b.provider && a.model === b.model && a.reasoningEffort === b.reasoningEffort
+
   // `force` re-selects even when the record says it is applied: the composer's own
   // model picker can move the Session without telling this plugin.
   async function applyModel(bot, { force = false } = {}) {
     const ref = await desiredModel(bot)
-    if (ref === undefined || (!force && bot.appliedModel === ref)) return ref
-    const route = splitRef(ref)
+    if (ref === undefined) return ref
+    const effort = await desiredEffort(bot, ref)
+    if (!force && bot.appliedModel === ref && (bot.appliedEffort ?? undefined) === effort) return ref
+    const route = { ...splitRef(ref), ...(effort === undefined ? {} : { reasoningEffort: effort }) }
     await selectSessionModel(rt.chatOf(bot.id), route)
     for (const sessionId of rt.groupSessionsOf(bot.id)) {
       await selectSessionModel(sessionId, route)
         .catch(error => rt.warn('ds-bot: model for %s in a group not applied: %s', bot.name, error))
     }
     bot.appliedModel = ref
+    if (effort === undefined) delete bot.appliedEffort
+    else bot.appliedEffort = effort
     await rt.save()
     return ref
   }
@@ -140,6 +196,7 @@ export function install(rt) {
 
   Object.assign(rt, {
     catalog, cachedCatalog: () => catalogCache.value, cachedDefault: () => pickDefault(catalogCache.value),
-    defaultRef, defaultModel, resolveModel, desiredModel, selectSessionModel, applyModel, waitForModel, syncModels,
+    defaultRef, defaultModel, resolveModel, desiredModel, reasoningOf, resolveEffort, desiredEffort,
+    selectSessionModel, applyModel, waitForModel, syncModels,
   })
 }

package/src/host/parts.js

@@ -107,6 +107,19 @@ export function historyEntry(event, group) {
   return { answer: false, who: ours ? 'bot' : 'user', text: skipped ? '' : text, keepAnswers: !skipped || (ours && source.resume === true) }
 }
 
+// A note with every heading in order but some translated (e.g. "## 目标" for "## Goals")
+// gets the headings as written, so the note is not thrown away over its headings alone.
+// A known heading in another place (repeated or out of order) keeps the note as it is.
+export function canonicalHeadings(note, names) {
+  const lines = note.split('\n')
+  const at = lines.flatMap((line, index) => /^##\s+\S/.test(line) ? [index] : [])
+  const heading = index => lines[index].replace(/^##\s+/, '').trim()
+  if (at.length !== names.length || at.every((index, n) => heading(index) === names[n])) return note
+  if (at.some((index, n) => names.includes(heading(index)) && heading(index) !== names[n])) return note
+  at.forEach((index, n) => { lines[index] = `## ${names[n]}` })
+  return lines.join('\n')
+}
+
 export function install(rt) {
   const { ctx, config, state } = rt
 
@@ -301,7 +314,7 @@ export function install(rt) {
     '',
     ...NOTE_SECTIONS.flatMap(([name, what]) => [`## ${name}`, `- [${what}]`, '']),
     'Rules:',
-    '- Do not make anything up. Leave a detail out rather than guess it. Keep identifiers, quotes, and numbers exact.',
+    '- Do not make anything up. Leave a detail out rather than guess it. Keep identifiers, quotes, and numbers exact, and write every file path in full, as it first appeared: never shorten it.',
     '- When a newer message contradicts an older one, the newer one wins; drop what is stale.',
     '- Your latest messages travel to the fresh conversation word for word, and in your own chat so does every message the user and other Bots sent you (long ones cut). Do not copy them whole; record what they mean and what they rely on. Still put in the facts, quotes, and error messages from them that the work needs: the move after this one leaves them behind.',
     '- If the conversation starts with a "[Handoff · part N]" message, it holds your previous note, and a "[Checkpoint N]" summary holds a condensed stretch of this part. Merge them: keep what is still true, drop what is stale, and add what is new. Nothing in them survives unless this note keeps it.',
@@ -342,7 +355,8 @@ export function install(rt) {
       })) assembler.push(chunk)
       const finish = assembler.finish
       if (finish.kind === 'error' || finish.kind === 'aborted') throw new Error(finish.failure?.message ?? finish.kind)
-      const note = assembler.blocks().filter(block => block.type === 'text').map(block => block.text).join('\n').trim()
+      const text = assembler.blocks().filter(block => block.type === 'text').map(block => block.text).join('\n').trim()
+      const note = missingSections(text).length > 0 ? canonicalHeadings(text, NOTE_SECTIONS.map(([name]) => name)) : text
       const missing = missingSections(note)
       if (finish.kind === 'max-tokens') {
         problem = 'it was cut off at the output limit'
@@ -696,6 +710,8 @@ export function install(rt) {
       await rt.selectSessionModel(freshId, model)
         .catch(error => rt.warn('ds-bot: model for the fresh part of %s not applied: %s', bot.name, error))
     }
+    await rt.applyPermission(bot, freshId)
+      .catch(error => rt.warn('ds-bot: permission for the fresh part of %s not applied: %s', bot.name, error))
     const segment = { sessionId: agent.id, endedAt: Date.now(), ...(tokens !== undefined ? { tokens } : {}), ...noted }
     if (room !== undefined) {
       room.segments ??= {}

package/src/host/permissions.js

@@ -0,0 +1,42 @@
+// Permissions. A Bot's permission preset is its own: kept on the Bot and set on every
+// Session it speaks from, so a fresh part or a new group Session keeps it.
+// DSH offers Auto review for the current Session only, so a Bot never keeps it.
+const SESSION_ONLY = 'auto'
+
+export function install(rt) {
+  const { ctx } = rt
+
+  const presets = () => ctx.get?.('permissionPresets')
+
+  // The presets DSH offers, or undefined when the profile has none.
+  function permissionCatalog() {
+    const service = presets()
+    if (service === undefined) return undefined
+    const { options, defaultPreset } = service.catalog()
+    return { options: options.filter(option => option.value !== SESSION_ONLY), defaultPreset }
+  }
+
+  // Sets the Bot's preset on one of its Sessions; a Bot without one keeps DSH's default.
+  async function applyPermission(bot, sessionId) {
+    const service = presets()
+    if (service === undefined || !bot.permission) return
+    const agent = await rt.resolveAgent(sessionId)
+    service.set(agent.session, bot.permission)
+  }
+
+  async function setPermission(bot, name) {
+    const service = presets()
+    if (service === undefined) throw new Error('Permissions are not available in this DeepSeek Harness')
+    const wanted = String(name ?? '').trim()
+    if (wanted === SESSION_ONLY) throw new Error('Auto review applies to one Session only and cannot be a Bot\'s permission')
+    service.resolve(wanted)
+    await applyPermission({ ...bot, permission: wanted }, rt.chatOf(bot.id))
+    bot.permission = wanted
+    for (const sessionId of rt.groupSessionsOf(bot.id)) {
+      await applyPermission(bot, sessionId)
+        .catch(error => rt.warn('ds-bot: permission for %s in a group not applied: %s', bot.name, error))
+    }
+  }
+
+  Object.assign(rt, { permissionCatalog, applyPermission, setPermission })
+}

package/src/host/roster.js

@@ -54,13 +54,14 @@ 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, copyOf, pickModel = false }) {
+  async function createBot({ name: botName, role = '', instructions = '', color, brief = '', createdBy, main = false, avatar, model, effort, copyOf, pickModel = false }) {
     const cleanName = String(botName ?? '').trim().slice(0, 40)
     if (cleanName === '') throw new Error('A Bot needs a name')
     if (rt.findBot(cleanName)) throw new Error(`A Bot named ${cleanName} already exists`)
     const cleanAvatarValue = cleanAvatar(avatar)
     // 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)
     state.bots[id] = {
       id,
@@ -70,6 +71,7 @@ export function install(rt) {
       ...(isColor(currentColor(color)) ? { color: currentColor(color) } : {}),
       ...(cleanAvatarValue ? { avatar: cleanAvatarValue } : {}),
       ...(modelRef ? { model: modelRef } : {}),
+      ...(effortId ? { effort: effortId } : {}),
       instructions: String(instructions).trim(),
       createdAt: Date.now(),
       createdBy: createdBy ?? null,
@@ -126,6 +128,7 @@ export function install(rt) {
       color: bot.color,
       avatar: bot.avatar,
       model: served ? bot.model : undefined,
+      effort: served ? bot.effort : undefined,
       copyOf: bot.id,
     })
   }
@@ -159,6 +162,16 @@ export function install(rt) {
       else bot.model = await rt.resolveModel(patch.model)
       modelChanged = true
     }
+    if (patch.effort !== undefined) {
+      if (patch.effort === null || patch.effort === '') delete bot.effort
+      else {
+        const ref = bot.model ?? bot.appliedModel
+        if (ref === undefined) throw new Error('Pick a model before choosing a thinking level')
+        bot.effort = await rt.resolveEffort(ref, patch.effort)
+      }
+      modelChanged = true
+    }
+    if (patch.permission !== undefined) await rt.setPermission(bot, patch.permission)
     await rt.save()
     if (modelChanged) await rt.applyModel(bot, { force: true })
     if (bot.model && bot.kickoff !== undefined) {