dsh-erpbot 0.1.0 → 0.1.1

package/src/assistant/index.js

@@ -38,6 +38,10 @@
       chatBots.forEach((id) => { chatStates[id] = emptyState() })
       const chatSubs = new Set()
       let chatCtx = null
+      /** The `remote.agentTeams` client namespace, injected by mount.js so the
+       *  team page can enable Team mode without resolving the `remote` service
+       *  (which erpbot does not inject). */
+      let teamRemote = null
 
       /** Resolve one client service lazily (sessions / workspaces / uiWorkspace). */
       function assistantService(name) {
@@ -49,6 +53,11 @@
         }
       }
 
+      /** Wire the `remote.agentTeams` namespace for enabling Team mode. */
+      function setTeamRemote(agentTeams) {
+        teamRemote = agentTeams || null
+      }
+
       /** Notify every React subscriber with the fresh map. */
       function notifyChat() {
         chatSubs.forEach((fn) => {
@@ -88,6 +97,29 @@
         return snap || emptyState()
       }
 
+      /**
+       * Aggregate activity across every bot, as one boolean. The rail's brand
+       * avatar shows a single status dot, so it needs "is anything running"
+       * rather than four separate tones; calling useChatState per bot inside a
+       * loop would break the rules of hooks.
+       */
+      function readChatBusy() {
+        return chatBots.some((id) => {
+          const state = chatStates[id]
+          return !!(state && (state.pending || state.running))
+        })
+      }
+
+      /** React binding for the aggregate activity flag. */
+      function useChatBusy() {
+        const [busy, setBusy] = React.useState(() => readChatBusy())
+        React.useEffect(() => {
+          setBusy(readChatBusy())
+          return subscribeChat(() => setBusy(readChatBusy()))
+        }, [])
+        return busy
+      }
+
       /** Status tone used by the header dot. */
       function chatTone(state) {
         if (!state) return ''
@@ -98,10 +130,23 @@
         return ''
       }
 
-      /** Read the persisted session id of one bot. */
+      /** Bot ids used before the pinyin → English rename, for storage migration. */
+      const LEGACY_BOT_IDS = { finance: 'cai', funds: 'zi', forecast: 'tui', tax: 'shui' }
+
+      /** Read the persisted session id of one bot, migrating a pre-rename key once. */
       function readSessionId(botId) {
         try {
-          return window.localStorage.getItem(SESSION_PREFIX + botId) || null
+          const current = window.localStorage.getItem(SESSION_PREFIX + botId)
+          if (current) return current
+          /* The rename changed the key suffix; carry the legacy id over so an
+             existing conversation is not silently replaced by a fresh one. */
+          const legacy = LEGACY_BOT_IDS[botId]
+          if (!legacy) return null
+          const old = window.localStorage.getItem(SESSION_PREFIX + legacy)
+          if (!old) return null
+          window.localStorage.setItem(SESSION_PREFIX + botId, old)
+          window.localStorage.removeItem(SESSION_PREFIX + legacy)
+          return old
         } catch (error) {
           return null
         }
@@ -219,6 +264,55 @@
         return rows.slice(0, LIST_LIMIT)
       }
 
+      /**
+       * The resident Session instance's own blank bit — the earliest truthful
+       * signal that a conversation left its blank state.
+       *
+       * The list snapshot only flips `blank` once the `sessionListMetadata`
+       * projection folds the first `turn/start`, which trails the accepted
+       * submission by a tick. A retained Session flips its own `blankBit`
+       * synchronously inside `acceptPrompt`, so reading the instance closes
+       * that gap: the welcome block disappears the moment the composer accepts
+       * the message instead of when the projection catches up.
+       * @param sessionId - Session to inspect.
+       * @returns the blank bit, or undefined when no resident instance is held.
+       */
+      function residentBlank(sessionId) {
+        if (sessionId === null) return undefined
+        try {
+          const sessions = assistantService('sessions')
+          if (sessions === null || typeof sessions.binding !== 'function') return undefined
+          const binding = sessions.binding(sessionId)
+          if (binding === undefined || binding === null) return undefined
+          const session = binding.session
+          if (session === undefined || session === null || typeof session.getSnapshot !== 'function') return undefined
+          const snapshot = session.getSnapshot()
+          if (snapshot === undefined || snapshot === null) return undefined
+          /* A running/attempted session is never blank even when the projection
+             has not folded its first turn/start yet. */
+          if (snapshot.running === true || snapshot.promptAttempted === true || snapshot.awaitingFirstTurn === true) return false
+          if (typeof snapshot.blank === 'boolean') return snapshot.blank
+        } catch (error) {
+          return undefined
+        }
+        return undefined
+      }
+
+      /**
+       * Blank state for one session: the resident instance first, the list row
+       * second, the caller's cached value last.
+       * @param sessionId - Session to inspect.
+       * @param row - matching session-list row, when the list knows the Session.
+       * @param fallback - value to keep when neither source is available.
+       * @returns the resolved blank bit.
+       */
+      function resolveBlank(sessionId, row, fallback) {
+        const resident = residentBlank(sessionId)
+        if (resident !== undefined) return resident
+        if (row !== undefined) return row.blank === true
+        return fallback
+      }
+
       /** Recompute one bot's session list and current status. */
       function refreshChat(botId) {
         const state = chatStates[botId]
@@ -229,13 +323,14 @@
           ? assistantService('sessions').list.getSnapshot()
           : null
         const row = catalog !== null && state.sessionId !== null ? catalog.byId[state.sessionId] : undefined
+        const blank = resolveBlank(state.sessionId, row, state.blank)
         patchChat(botId, {
           sessions: rows,
           running: current ? current.running : false,
           pending: current ? current.pending : false,
           unread: current ? current.unread : false,
-          blank: row !== undefined ? row.blank === true : state.blank,
-          fresh: state.fresh && row !== undefined && row.blank !== true ? false : state.fresh,
+          blank,
+          fresh: state.fresh && blank === false ? false : state.fresh,
         })
       }
 
@@ -349,6 +444,244 @@
         }
       }
 
+      /** Write a prompt into the team composer's draft (best effort). */
+      function prefillTeamChat(text) {
+        try {
+          if (teamState.sessionId === null || text === '') return
+          const sessions = assistantService('sessions')
+          if (sessions === null) return
+          const binding = sessions.binding(teamState.sessionId)
+          const scoped = sessions.scope(teamState.sessionId)
+          const conversation = scoped === undefined ? undefined : scoped.get('conversation')
+          if (binding === undefined || conversation === undefined) return
+          conversation.input.requestDraftInitialization(binding, { prompt: text, whenDraftExists: 'replace' })
+        } catch (error) {
+          console.warn('[dsh-erpbot] team prefill failed', error)
+        }
+      }
+
+      /* =====================================================================
+       * TEAM CHAT — the "团队模式" page embeds one root session whose Team mode
+       * is enabled. This is the same embedding trick as a single bot's chat
+       * (conversation.content), except the session is created in the shared team
+       * workspace and then remote.agentTeams.setEnabled turns on the board, so
+       * the official member tree + task board slots render inside this session.
+       * ===================================================================== */
+
+      /** Team chat state, independent of the four single-bot states. */
+      let teamState = emptyState()
+
+      /** Read the team session id, migrating nothing (team had no pinyin id). */
+      function readTeamSessionId() {
+        try {
+          return window.localStorage.getItem('dsh-erpbot.team.session.v1') || null
+        } catch (error) {
+          return null
+        }
+      }
+
+      /** Persist (or clear) the team session id. */
+      function writeTeamSessionId(id) {
+        try {
+          if (id) window.localStorage.setItem('dsh-erpbot.team.session.v1', id)
+          else window.localStorage.removeItem('dsh-erpbot.team.session.v1')
+        } catch (error) {
+          /* storage may be unavailable */
+        }
+      }
+
+      /** Create or reuse the shared team workspace via the host route. */
+      async function ensureTeamWorkspace() {
+        const response = await fetch('/erp/team/workspace', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: '{}',
+        })
+        const data = await response.json().catch(() => null)
+        if (!response.ok || data === null || data.ok !== true) {
+          throw new Error(data !== null && data.error ? data.error.message : 'team workspace unavailable')
+        }
+        return { workspaceId: data.workspaceId, path: data.path || '' }
+      }
+
+      /** Ensure the team root session exists, is retained, and has Team mode on. */
+      async function ensureTeamChat() {
+        if (teamState.phase === 'ready' && teamState.reference !== null) return teamState.reference
+        if (teamState.phase === 'preparing') return null
+        if (assistantCtxMissing()) {
+          teamState = Object.assign({}, teamState, { phase: 'unsupported', error: 'chat services unavailable' })
+          notifyTeam()
+          return null
+        }
+        teamState = Object.assign({}, teamState, { phase: 'preparing', error: null })
+        notifyTeam()
+        try {
+          const workspace = await ensureTeamWorkspace()
+          const sessions = assistantService('sessions')
+          const stored = readTeamSessionId()
+          let id = null
+          if (stored !== null) {
+            const catalog = sessions.list.getSnapshot()
+            const row = catalog.byId[stored]
+            if (row !== undefined && row.origin === undefined) id = stored
+          }
+          if (id === null) {
+            id = await sessions.create({ workspaceId: workspace.workspaceId })
+            writeTeamSessionId(id)
+          }
+          /* Retain FIRST: activating the session makes it a live root Agent,
+             which `remote.agentTeams.setEnabled` requires (its host half calls
+             `subagents.rootOf(agent)`, which rejects a not-yet-live session). */
+          const reference = sessions.retain(id, { source: 'erpbot-team' })
+          /* Now enable Team mode on this live root session so the official
+             member tree + task board slots render. */
+          try {
+            if (teamRemote !== null && typeof teamRemote.setEnabled === 'function') {
+              const response = await teamRemote.setEnabled(id, true)
+              if (response && response.ok === false) {
+                console.warn('[dsh-erpbot] team mode enable rejected:', response.error)
+              }
+            } else {
+              console.warn('[dsh-erpbot] team remote unavailable, team mode not enabled')
+            }
+          } catch (error) {
+            console.warn('[dsh-erpbot] team mode enable failed', error)
+          }
+          teamState = Object.assign({}, teamState, {
+            phase: 'ready',
+            workspaceId: workspace.workspaceId,
+            workspacePath: workspace.path,
+            sessionId: id,
+            reference,
+            error: null,
+          })
+          notifyTeam()
+          return reference
+        } catch (error) {
+          teamState = Object.assign({}, teamState, { phase: 'error', error: String((error && error.message) || error) })
+          notifyTeam()
+          return null
+        }
+      }
+
+      /** Notify every React subscriber of the team state change. */
+      function notifyTeam() {
+        notifyChat()
+      }
+
+      /** React binding for the team chat state. */
+      function useTeamChat() {
+        const [snap, setSnap] = React.useState(teamState)
+        React.useEffect(() => {
+          setSnap(teamState)
+          const off = subscribeChat(() => setSnap(teamState))
+          return () => off()
+        }, [])
+        return snap || emptyState()
+      }
+
+      /** Rows of the team workspace's sessions (current blank included). */
+      function teamSessionRows() {
+        const workspaces = assistantService('workspaces')
+        const sessions = assistantService('sessions')
+        if (workspaces === null || sessions === null || teamState.workspaceId === null) return []
+        const catalog = sessions.list.getSnapshot()
+        const workspace = (workspaces.list.getSnapshot().items || [])
+          .find((item) => item.workspaceId === teamState.workspaceId)
+        if (workspace === undefined) return []
+        const uiSession = assistantService('uiSession')
+        const statuses = uiSession !== null ? uiSession.sessionStatus.getSnapshot() : null
+        const rows = []
+        for (const id of workspace.sessionIds) {
+          const row = catalog.byId[id]
+          if (row === undefined) continue
+          if (row.blank === true && id !== teamState.sessionId) continue
+          const status = statuses !== null && statuses !== undefined ? statuses.get(id) : undefined
+          rows.push({
+            id,
+            title: row.title || row.displayTitle || t('ai.blankChat'),
+            at: row.updatedAt || 0,
+            blank: row.blank === true,
+            running: status !== undefined ? status.running === true : row.running === true,
+            pending: status !== undefined && status.pendingInteraction !== undefined && status.pendingInteraction !== null,
+            unread: status !== undefined && status.completionUnread === true,
+          })
+        }
+        rows.sort((a, b) => b.at - a.at)
+        return rows.slice(0, LIST_LIMIT)
+      }
+
+      /** Refresh the team session's status, sessions list + current session. */
+      function refreshTeamChat() {
+        if (assistantCtxMissing() || teamState.workspaceId === null) return
+        const sessions = assistantService('sessions')
+        const rows = teamSessionRows()
+        const current = rows.find((row) => row.id === teamState.sessionId)
+        const catalog = sessions !== null ? sessions.list.getSnapshot() : null
+        const row = catalog !== null && teamState.sessionId !== null ? catalog.byId[teamState.sessionId] : undefined
+        const blank = resolveBlank(teamState.sessionId, row, teamState.blank)
+        teamState = Object.assign({}, teamState, {
+          sessions: rows,
+          running: current ? current.running : false,
+          pending: current ? current.pending : false,
+          unread: current ? current.unread : false,
+          blank,
+          fresh: teamState.fresh && blank === false ? false : teamState.fresh,
+        })
+        notifyTeam()
+      }
+
+      /** Switch the team page to another session of its workspace. */
+      function switchTeamSession(id) {
+        const sessions = assistantService('sessions')
+        if (sessions === null) return
+        try {
+          const reference = sessions.retain(id, { source: 'erpbot-team' })
+          const previous = teamState.reference
+          teamState = Object.assign({}, teamState, { sessionId: id, reference, error: null, fresh: false })
+          writeTeamSessionId(id)
+          if (previous !== null && previous !== reference) {
+            setTimeout(() => { try { previous.release() } catch (error) { /* released */ } }, 0)
+          }
+          refreshTeamChat()
+        } catch (error) {
+          teamState = Object.assign({}, teamState, { error: String((error && error.message) || error) })
+          notifyTeam()
+        }
+      }
+
+      /** Create a fresh team root session, enable Team mode, switch to it. */
+      async function newTeamSession() {
+        if (teamState.phase !== 'ready') return
+        const sessions = assistantService('sessions')
+        if (sessions === null) return
+        try {
+          const id = await sessions.create({ workspaceId: teamState.workspaceId })
+          /* Retain first so the session is a live root, then enable Team mode. */
+          const previous = teamState.reference
+          const reference = sessions.retain(id, { source: 'erpbot-team' })
+          try {
+            if (teamRemote !== null && typeof teamRemote.setEnabled === 'function') {
+              const response = await teamRemote.setEnabled(id, true)
+              if (response && response.ok === false) {
+                console.warn('[dsh-erpbot] team mode enable rejected:', response.error)
+              }
+            }
+          } catch (error) {
+            console.warn('[dsh-erpbot] team mode enable failed', error)
+          }
+          teamState = Object.assign({}, teamState, { sessionId: id, reference, error: null, blank: true, fresh: true })
+          writeTeamSessionId(id)
+          if (previous !== null && previous !== reference) {
+            setTimeout(() => { try { previous.release() } catch (error) { /* released */ } }, 0)
+          }
+          refreshTeamChat()
+        } catch (error) {
+          teamState = Object.assign({}, teamState, { error: String((error && error.message) || error) })
+          notifyTeam()
+        }
+      }
+
       /** Open / close one bot's session list. */
       function toggleChatList(botId) {
         const state = chatStates[botId] || emptyState()
@@ -440,18 +773,70 @@
         chatCtx = ctx
       }
 
+      /**
+       * The team root session's embedded conversation. Identical to
+       * BotChatSurface but bound to the team state (a shared workspace session
+       * with Team mode on), so the official member tree + task board render.
+       * @param props - `{ kit }`.
+       * @returns the embedded conversation element.
+       */
+      function BotTeamSurface(props) {
+        const kit = props.kit || {}
+        const state = useTeamChat()
+
+        if (state.phase === 'idle' || state.phase === 'preparing') {
+          return h('div', { className: 'assist-note bot-note' }, t('ai.preparing'))
+        }
+        if (state.phase === 'error') {
+          return h('div', { className: 'assist-note bot-note' },
+            h('span', null, t('ai.error') + ' - ' + String(state.error || '')),
+            h('button', {
+              className: 'assist-link',
+              type: 'button',
+              onClick: () => {
+                teamState = Object.assign({}, teamState, { phase: 'idle', error: null })
+                notifyTeam()
+                ensureTeamChat()
+              },
+            }, t('ai.retry')))
+        }
+        if (state.phase === 'unsupported' || state.reference === null
+          || typeof kit.SessionProvider !== 'function' || typeof kit.renderFactorySlot !== 'function') {
+          return h('div', { className: 'assist-note bot-note' },
+            h('span', null, t('ai.fallback')))
+        }
+
+        return h('div', { className: 'bot-conversation team-conversation', 'data-bot': 'team' },
+          h(kit.SessionProvider, { session: state.reference },
+            kit.renderFactorySlot('conversation.content', {
+              variant: 'embedded',
+              phase: 'active',
+              hero: false,
+            }, BOT_FACTORY_OPTIONS)))
+      }
+
       return {
         chatTone,
         useChatState,
+        useChatBusy,
+        readChatBusy,
         ensureChat,
+        ensureTeamChat,
+        useTeamChat,
         refreshChat,
+        refreshTeamChat,
         switchChatSession,
         newChatSession,
+        newTeamSession,
+        switchTeamSession,
         prefillChat,
+        prefillTeamChat,
         toggleChatList,
         primeChats,
         setAssistantCtx,
+        setTeamRemote,
         BotChatSurface,
+        BotTeamSurface,
         assistantTime,
         chatSessions: (botId) => (chatStates[botId] || emptyState()).sessions,
         chatState: (botId) => chatStates[botId] || emptyState(),

package/src/bot-data.js

@@ -3,18 +3,18 @@
      * 纯数据片段：无函数、无 h(、无 React；由 workbench / entry 通过 deps 注入。
      * ===================================================================== */
 
-    const BOT_IDS = ['cai', 'zi', 'tui', 'shui']
+    const BOT_IDS = ['finance', 'funds', 'forecast', 'tax']
 
     const SKILL_IDS = {
-      cai: ['vouchers', 'ledgers', 'ar-aging', 'payables', 'fixed-assets', 'close', 'statements', 'workpapers'],
-      zi: ['accounts', 'payments', 'recon', 'plan', 'restricted', 'bills'],
-      tui: ['budget', 'forecast', 'scenario', 'assumption', 'allocation', 'mgmt-report', 'variance', 'cash-plan'],
-      shui: ['output-invoice', 'input-verify', 'invoice-check', 'file', 'pay', 'burden'],
+      finance: ['vouchers', 'ledgers', 'ar-aging', 'payables', 'fixed-assets', 'close', 'statements', 'workpapers'],
+      funds: ['accounts', 'payments', 'recon', 'plan', 'restricted', 'bills'],
+      forecast: ['budget', 'forecast', 'scenario', 'assumption', 'allocation', 'mgmt-report', 'variance', 'cash-plan'],
+      tax: ['output-invoice', 'input-verify', 'invoice-check', 'file', 'pay', 'burden'],
     }
 
     const BOTS = {
-      cai: {
-        id: 'cai',
+      finance: {
+        id: 'finance',
         name: { zh: '账房', en: 'The Ledger' },
         short: { zh: '账', en: 'L' },
         role: { zh: '把账记对、把账关好、把证据留全', en: 'Keep the books correct, close them cleanly, keep the evidence complete' },
@@ -46,8 +46,8 @@
           en: 'For questions about whether the books balance, where the close stands or whether statements are ready: give the conclusion first, then the definition and the evidence path (statements, workpapers, ledgers, vouchers). Name the document or step behind every gap.',
         },
       },
-      zi: {
-        id: 'zi',
+      funds: {
+        id: 'funds',
         name: { zh: '司库', en: 'The Treasurer' },
         short: { zh: '司', en: 'T' },
         role: { zh: '守住可支付能力与安全垫', en: 'Guard the payment capacity and the safety buffer' },
@@ -79,8 +79,8 @@
           en: 'For questions about how much cash is available, whether payments are covered or where the gap is: give the available balance and the buffer verdict first, then the timestamp, restrictions and unreconciled items. Flag payment dependencies when they matter.',
         },
       },
-      tui: {
-        id: 'tui',
+      forecast: {
+        id: 'forecast',
         name: { zh: '军师', en: 'The Planner' },
         short: { zh: '军', en: 'P' },
         role: { zh: '把不确定性与假设讲清楚', en: 'Make uncertainty and assumptions explicit' },
@@ -112,8 +112,8 @@
           en: 'For questions about budget headroom, the next three months or what an assumption change does: give the range and the assumption version first, then the conclusion and sensitivities. Keep forecast and commitment separate.',
         },
       },
-      shui: {
-        id: 'shui',
+      tax: {
+        id: 'tax',
         name: { zh: '税官', en: 'The Tax Officer' },
         short: { zh: '税', en: 'X' },
         role: { zh: '不错报、不漏报、红线可见', en: 'No wrong filing, no missed filing, red lines visible' },
@@ -146,3 +146,15 @@
         },
       },
     }
+
+    /** Skill dependency declarations: skill name → prerequisite skill names.
+     *  When a user adds a skill, the UI warns if any prerequisite is missing.
+     *  These are only the cross-skill deps that matter at binding time; the
+     *  skill's own SKILL.md is the authority for runtime requirements. */
+    const SKILL_DEPS = {
+      /* DSH standard skills that need MCP channels or other skills. */
+      'intelligent-recon': ['bank-mcp-channel'],
+      'invoice-check': ['tax-system-channel'],
+      'tax-filing-assistant': ['tax-system-channel'],
+      'bank-rpa': ['bank-mcp-channel'],
+    }

package/src/bundle.json

@@ -147,6 +147,7 @@
         "BOTS",
         "PLATFORM_SKILLS",
         "SKILL_IDS",
+        "SKILL_DEPS",
         "CARDS",
         "CARD_AUTO_MS",
         "DONUT_ARCS",

package/src/cards/index.js

@@ -5,11 +5,16 @@
      * ===================================================================== */
 
     function createCards(deps) {
-      const { React, h, t, metricLabel, metricSub, PAGES, Icon, Spark, drawTrend } = deps
+      const { React, h, t, compactMoney, readLang, metricLabel, metricSub, PAGES, Icon, Spark, drawTrend } = deps
 
       /* Legacy deep links: the data and platform pages were merged into one
-         base page, so `#/erp/shu` and `#/erp/guan` now land on it. */
-      const HASH_ALIAS = { shu: 'base', guan: 'base' }
+         base page, so `#/erp/shu` and `#/erp/guan` now land on it. The four bot
+         pages were renamed from pinyin ids to English ones, so the old hashes
+         still resolve instead of falling back to the overview. */
+      const HASH_ALIAS = {
+        shu: 'base', guan: 'base',
+        cai: 'finance', zi: 'funds', tui: 'forecast', shui: 'tax',
+      }
 
       /** Read the page id out of `#/erp/<id>`; unknown ids fall back to overview. */
       function readHashPage() {
@@ -305,6 +310,12 @@
       /**
        * Tiny chart drawn on the block card: bars for 账, a line for 资, a ring for
        * 推. White with opacities so it reads on every card tint.
+       *
+       * The centre figure is formatted for the ring, not printed in full. The
+       * ring's hole is only about half its width, so "¥12,000,000.00" at full
+       * length was wider than the hole it sits in and spilled across both arcs.
+       * compactMoney scales it to "¥1,200万"; the exact figure still appears in
+       * the card's own cells row and in the detail modal, so nothing is lost.
        */
       function MiniChart(props) {
         const chart = props.chart || {}
@@ -330,6 +341,9 @@
             h('i', { style: { background: 'rgba(255,255,255,' + slice.tone + ')' } }),
             h('span', null, slice.key ? t(slice.key) : ''),
             h('b', null, slice.v + '%')))
+          const centre = chart.total
+            ? (compactMoney ? compactMoney(chart.total, readLang ? readLang() : 'zh') : chart.total)
+            : ''
           return h('div', { className: 'visa-chart donut' },
             h('div', { className: 'mini-donut' },
               h('svg', { viewBox: '0 0 44 44', 'aria-hidden': 'true' },
@@ -340,7 +354,7 @@
                   }),
                   arcs)),
               h('div', { className: 'mini-donut-center' },
-                h('b', null, chart.total || ''),
+                h('b', null, centre),
                 chart.totalLabelKey ? h('span', null, t(chart.totalLabelKey)) : null)),
             h('ul', { className: 'mini-legend' }, legend))
         }