agentworkshop 0.7.27 → 0.7.33

package/server/services/workshop/prompts/loader.ts

@@ -31,13 +31,34 @@ interface CacheEntry {
 
 const cache = new Map<string, CacheEntry>()
 
-/** 包内资产 prompts 目录(播种源;不存在返回 null) */
+/** 包内资产 prompts 目录(播种源;不存在返回 null)
+ *
+ *  解析顺序(不可依赖 import.meta.url 的层数 —— 产物里本模块被内联进
+ *  `.output/server/chunks/_/nitro.mjs`,相对层数与源码布局不同,早先写死
+ *  `../../../..` 会算到 `<root>` 而不是 `<root>/.output`,导致直接
+ *  `node .output/server/index.mjs` 启动时播种源为 null → 回退路径又不存在
+ *  → 启动即 `PROMPTS_DIR_MISSING`):
+ *    ① AW_PACKAGE_ROOT(scripts/start.mjs 注入的包根)
+ *    ② <cwd>/.output/.AgentWorkShop/prompts(产物自带副本;与 schema.json 同址)
+ *    ③ 源码布局回退:本文件 ../../../../.AgentWorkShop/prompts
+ */
 function packagedPromptsDir(): string | null {
-  const packageRoot = process.env.AW_PACKAGE_ROOT
-    ? resolve(process.env.AW_PACKAGE_ROOT)
-    : resolve(dirname(fileURLToPath(import.meta.url)), '../../../..')
-  const candidate = join(packageRoot, '.AgentWorkShop', 'prompts')
-  return existsSync(candidate) ? candidate : null
+  const candidates: string[] = []
+  if (process.env.AW_PACKAGE_ROOT) {
+    candidates.push(resolve(process.env.AW_PACKAGE_ROOT))
+  }
+  candidates.push(resolve(process.cwd()))
+  candidates.push(resolve(dirname(fileURLToPath(import.meta.url)), '../../../..'))
+  // cwd 与源码布局两种锚点 × { 产物内路径, 检出根路径 }
+  const dirs: string[] = []
+  for (const base of candidates) {
+    dirs.push(join(base, '.output', '.AgentWorkShop', 'prompts'))
+    dirs.push(join(base, '.AgentWorkShop', 'prompts'))
+  }
+  for (const candidate of dirs) {
+    if (existsSync(candidate)) return candidate
+  }
+  return null
 }
 
 /** 首次/每次解析把包内初始 prompts 补种到 ~/.AgentWorkShop/prompts(逐文件只补缺,不覆盖)。
@@ -84,6 +105,11 @@ export function promptsDir(): string {
     if (existsSync(candidate)) return candidate
   }
 
+  // ②b 产物自带副本(直接 node .output/server/index.mjs 启动,无 AW_PACKAGE_ROOT、
+  //     也无 cwd 内 ./.AgentWorkShop 时,这是唯一可用的本地目录)
+  const bundled = join(resolve(process.cwd()), '.output', '.AgentWorkShop', 'prompts')
+  if (existsSync(bundled)) return bundled
+
   // ③ ~/.AgentWorkShop/prompts
   if (existsSync(homePrompts)) return homePrompts
   throw new AppError(500, 'PROMPTS_DIR_MISSING', `prompts 目录不存在(已尝试自动播种): ${homePrompts};可用 AW_PROMPTS_DIR 指定`)

package/server/services/workshop/runtime/manager.ts

@@ -45,10 +45,12 @@ import { hasTerminalSession, sweepTerminalSessions } from '../agents/harness-ter
 import { knownHarnesses } from '../agents/registry'
 import { assertHarnessUsable } from '../agents/harness-availability'
 import { hostToolsForRole } from '../agents/host-tool-bridge'
+import { listPluginTools, pluginOfTool } from '../agents/plugin-tools'
 import { TEAM_AGENT_ID, type MemoryRepo } from '../db/memory.repo'
 import type { UserRepo } from '../db/user.repo'
 import type { ChannelEventRepo } from '../db/channel-event.repo'
 import type { ChannelTemplateRepo, ChannelTemplateMember } from '../db/channel-template.repo'
+import { getChannelPluginsRepo, type ChannelPluginToggle } from '../db/channel-plugins.repo'
 
 const log = createLogger('workshop.manager')
 
@@ -323,6 +325,8 @@ export class AgentChannelManager {
   private readonly memoryEmbedder = createEnvEmbeddingProvider()
   /** 反思游标:每 agent 上次聚合的当月任务数(月度幂等增量判定) */
   private readonly reflectCounts = new Map<string, number>()
+  /** agent 最近一次工具 invoke 时刻(调度器停滞看门狗的活性源;工具调用即健康推进) */
+  private readonly lastToolInvokeAt = new Map<string, number>()
 
   constructor(private deps: ManagerDeps) {
     // 记忆衰减清理定时器(失败只记日志,绝不抛出;unref 不阻进程退出;非法/非正 env 回退默认)
@@ -463,9 +467,11 @@ export class AgentChannelManager {
     }
     const trigger = memorySettings().reflect_trigger
     const month = new Date().toISOString().slice(0, 7)
-    for (const agentId of this.deps.repos.memories.listMemoryAgentIds()) {
-      const rows = this.deps.repos.memories.listByAgentWithRowid(agentId, 1_000_000)
-        .filter(r => r.kind === 'episodic-task' && r.createdAt.slice(0, 7) === month)
+    const memories = this.deps.repos.memories
+    for (const agentId of memories.listMemoryAgentIds()) {
+      // 条件下推到 SQL:原先拉 limit=1_000_000 全量再 JS filter,代价随记忆总量无上限增长。
+      // 这里按 (agent, kind, 当月) 精确取行 —— 返回量与实际增量同阶,且内存不随历史膨胀。
+      const rows = memories.listByAgentKindMonth(agentId, 'episodic-task', month)
       const prev = this.reflectCounts.get(agentId) ?? 0
       if (rows.length < trigger || rows.length <= prev) continue
       // 行可能跨 channel(历史迁移):按 channel 分组,各组建反思
@@ -694,6 +700,8 @@ export class AgentChannelManager {
     if (!lead) return
     const loop = new SchedulerLoop(cr, lead, {
       ...options,
+      // 停滞看门狗活性源:agent 最近一次工具 invoke 时刻(工具调用即健康推进)
+      toolActivityOf: (agentId: string) => this.lastToolInvokeAt.get(agentId) ?? null,
       // 调度快照的邮件上下文(lead 观察 worker 间通信的唯一来源;DB 为事实源)
       supervisionMail: limit => this.deps.repos.messages
         .listRecentByChannel(channelId, limit)
@@ -1109,16 +1117,13 @@ export class AgentChannelManager {
   // ===== Workspace(服务端持久化;按 owner 隔离)=====
 
   listWorkspaces(userId: string): Array<WorkspaceRow & { channelIds: string[] }> {
+    // 纯读:挂载引用的失效清理已下沉到 removeChannel 的级联
+    // (unmountChannelEverywhere)。早先这里在 .filter() 回调里 DELETE 挂载行,
+    // 使 GET /api/workshop/workspaces 与 GET /users/me 成为**有副作用的读** ——
+    // 读路径必须可重放、可缓存、可并发,不写库。
     return this.deps.repos.users.listWorkspaces(userId).map(ws => ({
       ...ws,
-      // 挂载引用自愈:channel 删除(removeChannel)不级联清理 workspace_channels,
-      // 死引用会让前端订阅永不到达(左栏"幽灵频道"+ 右栏空数据假象)——
-      // 读取时过滤并顺手删除挂载行,历史脏数据随读取收敛
-      channelIds: this.deps.repos.users.listMountedChannels(ws.id).filter((id) => {
-        if (this.deps.repos.channels.findById(id)) return true
-        this.deps.repos.users.unmountChannel(ws.id, id)
-        return false
-      }),
+      channelIds: this.deps.repos.users.listMountedChannels(ws.id),
     }))
   }
 
@@ -1279,6 +1284,9 @@ export class AgentChannelManager {
     }
     // 记忆级联清理:成员私有行 + team 公共行(防残留行污染他 channel 的 FTS/team 检索域)
     this.deps.repos.memories.deleteByChannel(channelId)
+    // workspace 挂载级联:不清理会留下"幽灵频道"(左栏有条目、右栏永空)——
+    // 这是 listWorkspaces 读路径兜底要解决的问题,现在在删除侧一次性收敛
+    this.deps.repos.users.unmountChannelEverywhere(channelId)
     this.deps.repos.channels.remove(channelId)
   }
 
@@ -1752,8 +1760,11 @@ export class AgentChannelManager {
   // ===== AgentTeam 管理面(模板编组 + 批量部署;v10 可见性隔离) =====
 
   /** 创建 AgentTeam */
-  async createTeam(input: { name: string, description?: string, visibility?: string, ownerUserId?: string | null }): Promise<AgentTeamDetail> {
+  async createTeam(input: { name: string, description?: string, visibility?: string, ownerUserId?: string | null, plugins?: ChannelPluginToggle[] }): Promise<AgentTeamDetail> {
     const row = this.deps.repos.teams.create({ name: input.name, description: input.description, visibility: input.visibility, ownerUserId: input.ownerUserId ?? null })
+    // 建队时的插件勾选:以 team id 为键落 channel_plugins(team 作用域偏好),
+    // 部署 deployTeamToChannel 时传导到目标 channel(未配置 = 全启用,向后兼容)
+    if (input.plugins?.length) getChannelPluginsRepo().setMany(row.id, input.plugins)
     return this.teamDetailOf(row)
   }
 
@@ -1848,6 +1859,12 @@ export class AgentChannelManager {
       })
       agents.push(inst)
     }
+    // 团队插件开关传导:建队/团队设置显式配置过的开关随部署落到目标 channel
+    // (以 team id 为键的偏好 → 以 channel id 为键;工具注入与 dispatch 同源过滤)
+    const teamPlugins = getChannelPluginsRepo().explicitFor(input.teamId)
+    if (teamPlugins && teamPlugins.size) {
+      getChannelPluginsRepo().setMany(input.channelId, [...teamPlugins].map(([name, enabled]) => ({ name, enabled })))
+    }
     return { channelId: input.channelId, teamId: input.teamId, agents }
   }
 
@@ -2722,7 +2739,9 @@ export class AgentChannelManager {
 
   /**
    * harness 无关全量工具直调(agent token 鉴权;stdio MCP 桥回程的唯一入口)。
-   * impl.dispatchHostTool(全引擎共享 host-tool-bridge)优先;未实现回退协作工具族。
+   * 插件工具最先(与 host-tool-bridge 同源过滤,不依赖引擎运行时 —— mock 等无引擎
+   * 工具面的成员经 REST invoke 同样可用);其余 impl.dispatchHostTool 优先,未实现
+   * 回退协作工具族。
    */
   async invokeHostTool(input: { agentId: string, token?: string, tool: string, args?: Record<string, unknown> }): Promise<{ text: string, isError?: boolean }> {
     const row = this.deps.repos.channelAgents.findById(input.agentId)
@@ -2734,6 +2753,27 @@ export class AgentChannelManager {
     // 工具执行错误(业务约束/目标不存在等)一律降级为 isError 文本——
     // 绝不让 AppError 以 unhandledRejection 逃逸拖垮 worker(stability-guard 会因此退出整进程)
     try {
+      // 活性登记:调度器停滞看门狗以「最近工具调用」为健康信号(见 SchedulerLoopOptions.toolActivityOf)
+      this.lastToolInvokeAt.set(input.agentId, Date.now())
+      // 插件工具:团队开关过滤 + handler 直调(ctx.omp 注册的自定义工具全 harness 同源)
+      const pluginTool = listPluginTools().get(input.tool)
+      if (pluginTool) {
+        const channelOff = getChannelPluginsRepo().explicitFor(row.channelId)
+        const owner = pluginOfTool(input.tool)
+        if (channelOff && owner && channelOff.get(owner) === false) {
+          return {
+            text: `该团队未启用插件「${owner}」,${input.tool} 不可用。可在团队设置→插件中开启。`,
+            isError: true,
+          }
+        }
+        const identity = {
+          agentId: row.id,
+          channelId: row.channelId,
+          role: (row.role === 'lead' ? 'lead' : 'worker') as 'lead' | 'worker',
+          name: row.name,
+        }
+        return await pluginTool.handler(input.args ?? {}, identity)
+      }
       const runtime = this.ensureAgentRuntime(row.channelId, input.agentId)
       if (runtime) {
         const viaImpl = await runtime.dispatchHostTool(input.tool, input.args ?? {})

package/server/services/workshop/runtime/scheduler-loop.ts

@@ -5,7 +5,7 @@
  * 支持三种执行模式:goal(满意度判断)/ loop(循环重放)/ pipeline(流水线)。
  * 权威契约见 docs/superpowers/plans/2026-08-13-agent-workshop-multi-agent.md 核心契约块 T5。
  */
-import { createLogger } from '../logger'
+import { createLogger } from '../logger'
 import { randomUUID } from 'node:crypto'
 import { TERMINAL_TASK_STATES } from '../types/task'
 import type { A2AMessage, ChannelMail } from '../types/a2a'
@@ -51,6 +51,9 @@ export interface SchedulerLoopOptions {
   stallMs?: number
   /** 调度快照邮件提供者(manager 注入;返回最新在前);未注入则快照 mail 为空 */
   supervisionMail?: (limit: number) => ChannelMail[]
+  /** agent 最近一次工具调用时刻(manager 注入;停滞看门狗的活性信号:
+   *  真实 LLM 长工具链不更新 progress 数字,健康工作不能被两轮 stallMs 误回收) */
+  toolActivityOf?: (agentId: string) => number | null
 }
 
 /** 空闲退避上限(指纹不变时 tick 间隔指数退避至此;事件 wake 立即恢复) */
@@ -60,6 +63,7 @@ export class SchedulerLoop {
   private readonly tickMs: number
   private readonly stallMs: number
   private readonly supervisionMail: ((limit: number) => ChannelMail[]) | null
+  private readonly toolActivityOf: ((agentId: string) => number | null) | null
   /** supervise 节流:最小间隔与最近一次执行时刻/信号指纹(token 效率) */
   private lastSuperviseAt = 0
   private lastFingerprint = ''
@@ -101,6 +105,7 @@ export class SchedulerLoop {
     this.tickMs = options.tickMs ?? 1000
     this.stallMs = options.stallMs ?? 300000
     this.supervisionMail = options.supervisionMail ?? null
+    this.toolActivityOf = options.toolActivityOf ?? null
   }
 
   /** 空闲退避:快照指纹连续不变的轮数(决定下次 tick 间隔) */
@@ -439,6 +444,18 @@ export class SchedulerLoop {
     const assigneeState = new Map(this.channelRuntime.getAgents().map(a => [a.agentId, a.getState()]))
     for (const task of tasks) {
       if (task.state !== 'WORKING') continue
+      // 工具调用即活性:最近 stallMs 内有工具invoke的任务视为健康推进,刷新基线并跳过看门狗。
+      // 真实 LLM worker 的长工具链(真实 PLC 写+等待回读)不更新 progress 数字,且回合间隙
+      // runtime 会短暂 idle——仅凭 progress 停滞会把健康任务误回收(实测 live-line 闭环任务
+      // 交付物已含 CLOSEDLOOP-OK 却被Canceled)。真停滞(无工具活动+无进度)仍走 notify→cancel。
+      const lastTool = this.toolActivityOf?.(task.assigneeId) ?? 0
+      const toolActive = lastTool > 0 && now - lastTool <= this.stallMs
+      if (toolActive) {
+        this.lastProgress.set(task.id, { progress: task.progress, at: now })
+        this.progressSeen.set(task.id, { progress: task.progress, at: now })
+        this.notified.delete(task.id)
+        continue
+      }
       if (assigneeState.get(task.assigneeId) === 'busy') {
         // busy 且 progress 长期不变:催一次 lead 介入(notify 到 assignee 本人,请其推进/汇报);
         // 尚未到基准时间或 progress 已变 → 刷新基线

package/server/services/workshop/scene/scene-layout.repo.ts

@@ -9,8 +9,9 @@
  * 应用级单例,写入 server/data/scene-layouts.json,进程内缓存,启动读盘。
  */
 
-import path from 'node:path'
-import { loadJsonFile, saveJsonFileAtomic } from '../json-store.mjs'
+import { join } from 'node:path'
+import { ensureDataDir } from '@/shared/config/home.mjs'
+import { loadJsonFile, saveJsonFileAtomic } from '../json-store.mjs'
 
 export interface SceneLayout {
   channelId: string
@@ -39,9 +40,8 @@ export interface SceneLayoutInput {
   workspaceId?: string
 }
 
-const DB_PATH = process.cwd().endsWith('server')
-  ? 'data/scene-layouts.json'
-  : path.join(process.cwd(), 'server', 'data', 'scene-layouts.json')
+// 配置根 .AgentWorkShop/data（ensureDataDir 自动迁移旧 cwd/server/data 位置）
+const DB_PATH = join(ensureDataDir(), 'scene-layouts.json')
 
 function load(): SceneLayout[] {
   const parsed = loadJsonFile(DB_PATH, [])

package/server/services/workshop/settings.ts

@@ -88,6 +88,14 @@ export interface HarnessSettings {
   opencode_command: string
   codex_command: string
   dsh_command: string
+  gemini_command: string
+  qwen_command: string
+  copilot_command: string
+  cursor_command: string
+  crush_command: string
+  goose_command: string
+  pi_command: string
+  hermes_command: string
   hitl_timeout_ms: number
 }
 export interface DcwSettings {
@@ -131,10 +139,20 @@ export interface DaqRuntimeSettings {
     defaultIntervalMs: number
     minIntervalMs: number
   }
+  /** WS 实时下发节拍(节点 publishIntervalMs 未显式指定时的默认值与下限;
+   *  与采样间隔解耦 —— 采集可以很快而前端仅按此节拍刷新) */
+  publish: {
+    defaultIntervalMs: number
+    minIntervalMs: number
+  }
   /** 时序查询节拍(bucketMs 缺省值与下限;samples/产线查询/Agent daq_query 共用) */
   query: {
     defaultBucketMs: number
     minBucketMs: number
+    /** 前端趋势图自动重新拉取(查询+重绘)间隔默认值 */
+    displayIntervalMs: number
+    /** 前端趋势图刷新间隔下限(前端钳制用) */
+    minDisplayIntervalMs: number
   }
   tsRetentionH: number
   frameRetentionH: number
@@ -172,12 +190,58 @@ export function daqRuntimeSettings(): DaqRuntimeSettings {
       defaultIntervalMs: Number(get('sampling.defaultIntervalMs', 5000)),
       minIntervalMs: Number(get('sampling.minIntervalMs', 1000)),
     },
+    publish: {
+      defaultIntervalMs: Number(get('publish.defaultIntervalMs', 1000)),
+      minIntervalMs: Number(get('publish.minIntervalMs', 0)),
+    },
     query: {
       defaultBucketMs: Number(get('query.defaultBucketMs', 15000)),
       minBucketMs: Number(get('query.minBucketMs', 1000)),
+      displayIntervalMs: Number(get('query.displayIntervalMs', 5000)),
+      minDisplayIntervalMs: Number(get('query.minDisplayIntervalMs', 500)),
     },
   }
 }
 export function securityHitlTimeoutMs(): number {
   return Number(effective()['security.hitl_timeout_ms'] ?? 180_000)
 }
+
+export interface AmlSettings {
+  python: { pythonBin: string, uvBin: string, indexUrl: string }
+  job: { timeoutMs: number, maxConcurrent: number, diskQuotaMb: number, stallMs: number, logTailLines: number }
+  dataset: { maxRows: number, retentionDays: number, allowCrossRecipe: boolean }
+  model: { retiredKeepDays: number }
+  gates: { nrmse: number, rolloutNrmse: number, valTestGap: number, minRows: number, minRuns: number }
+}
+/** AML 自动建模平台运行语义(live 键热生效;logTailLines 非描述符键,固定缺省) */
+export function amlSettings(): AmlSettings {
+  const e = effective()
+  const get = (k: string, dflt: unknown): unknown => (e[`aml.${k}`] === undefined ? dflt : e[`aml.${k}`])
+  return {
+    python: {
+      pythonBin: String(get('python.pythonBin', '')),
+      uvBin: String(get('python.uvBin', '')),
+      indexUrl: String(get('python.indexUrl', '')),
+    },
+    job: {
+      timeoutMs: Number(get('job.timeoutMs', 1_800_000)),
+      maxConcurrent: Number(get('job.maxConcurrent', 2)),
+      diskQuotaMb: Number(get('job.diskQuotaMb', 2048)),
+      stallMs: Number(get('job.stallMs', 600_000)),
+      logTailLines: 500,
+    },
+    dataset: {
+      maxRows: Number(get('dataset.maxRows', 200_000)),
+      retentionDays: Number(get('dataset.retentionDays', 30)),
+      allowCrossRecipe: Boolean(get('dataset.allowCrossRecipe', false)),
+    },
+    model: { retiredKeepDays: Number(get('model.retiredKeepDays', 90)) },
+    gates: {
+      nrmse: Number(get('gates.nrmse', 0.10)),
+      rolloutNrmse: Number(get('gates.rolloutNrmse', 0.25)),
+      valTestGap: Number(get('gates.valTestGap', 0.20)),
+      minRows: Number(get('gates.minRows', 500)),
+      minRuns: Number(get('gates.minRuns', 3)),
+    },
+  }
+}

package/shared/config/engine.mjs

@@ -60,6 +60,11 @@ export function loadDescriptors() {
     join(here, 'schema.json'),
     resolve(process.cwd(), 'shared', 'config', 'schema.json'),
     resolve(process.cwd(), 'config', 'schema.json'),
+    // 产物自带副本:nuxt 构建把 shared/config/schema.json 复制到
+    // .output/.AgentWorkShop/schema.json。直接 node .output/server/index.mjs
+    // 启动(无 scripts/start.mjs 注入 AW_PACKAGE_ROOT)时,这是唯一能找到描述符
+    // 的路径 —— 缺了它启动即 `找不到 schema.json` 崩,且报错只说"尝试了哪些路径"。
+    resolve(process.cwd(), '.output', '.AgentWorkShop', 'schema.json'),
   ]
   // 启动器注入的载荷根(start.mjs / dev-guard 恒设置;全局安装 = 包根,shared/ 随包发布)
   if (process.env.AW_PACKAGE_ROOT) {

package/shared/config/groups.mjs

@@ -0,0 +1,220 @@
+/**
+ * 配置分组注册表 —— 设置页分组的单一事实来源。
+ *
+ * 描述符(schema.json / 插件声明)只负责声明 `group`(分组 id);分组的标题、说明、
+ * 排序、默认折叠状态由本注册表给出。这样「后端 API 控制前端渲染」才成立:
+ * 前端不再自己扫描描述符猜分组,而是完全按服务端返回的 groups 顺序与元数据渲染。
+ *
+ * 三类来源(source):
+ *   builtin —— 由 schema.json 的声明顺序自动推导(不可删除,可改标题/排序)
+ *   user    —— 管理员经 /api/system/config-groups 创建
+ *   plugin  —— 插件装载期声明(ctx.config.defineGroup 或 manifest.configGroups);
+ *              插件卸载/热重载时自动摘除,不残留空分组
+ *
+ * 健壮性:任何描述符引用了未注册的 group id → 自动兜底注册(source=builtin,
+ * 标题取 id)。字段永不因为「分组没登记」而在设置页消失。
+ *
+ * 持久化:<configRoot>/config-groups.json
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+export const GROUPS_FILENAME = 'config-groups.json'
+
+/**
+ * 插件分组 id 规约:plugin-<插件名>[-<后缀>](合法标识符,可直接进 URL 与 i18n key)。
+ * 把插件声明的任意 id 收敛进自己的命名空间,避免两个插件用同一个 "network" 互相覆盖,
+ * 也保证插件卸载时能可靠识别并摘除自己声明的分组。
+ */
+export function pluginGroupId(pluginName, suffix) {
+  const ns = String(pluginName).replace(/[^A-Za-z0-9_-]/g, '-')
+  const sub = suffix == null || suffix === '' ? '' : `-${String(suffix).replace(/[^A-Za-z0-9_-]/g, '-')}`
+  return `plugin-${ns}${sub}`.slice(0, 48)
+}
+
+/** 插件声明的分组 id → 命名空间内 id(label 保持原样展示) */
+export function namespacedPluginGroupId(pluginName, declaredId) {
+  const raw = String(declaredId ?? '').trim()
+  if (!raw) return pluginGroupId(pluginName)
+  if (raw === 'default' || raw === String(pluginName)) return pluginGroupId(pluginName)
+  return pluginGroupId(pluginName, raw)
+}
+
+/** 插件默认配置分组 id(未显式声明 group 的字段落这里 → 每个插件天然一个独立分区) */
+export function defaultPluginGroupId(pluginName) {
+  return pluginGroupId(pluginName)
+}
+
+const ID_RE = /^[A-Za-z0-9_-]{1,48}$/
+
+/**
+ * 规范化分组定义。
+ * order 只在「显式给出」或调用方提供 fallbackOrder(新建分组时)才落值 ——
+ * 从磁盘读回的旧条目若没写 order,交给 mergeGroups 沿用内置声明顺序,
+ * 否则会平白跳到列表末尾。
+ * @returns {{ ok: true, group: object } | { ok: false, error: string }}
+ */
+export function normalizeGroup(def, { source = 'user', plugin = null, fallbackOrder } = {}) {
+  const d = def ?? {}
+  const id = String(d.id ?? '').trim()
+  if (!ID_RE.test(id)) {
+    return { ok: false, error: `分组 id 非法(仅字母数字_-，1~48 位): ${JSON.stringify(d.id)}` }
+  }
+  const label = String(d.label ?? d.labelKey ?? id).trim()
+  if (!label) return { ok: false, error: `分组 ${id}: label 不能为空` }
+  const order = Number.isFinite(Number(d.order)) ? Number(d.order) : fallbackOrder
+  const group = {
+    id,
+    label,
+    description: String(d.description ?? ''),
+    /** 前端默认是否折叠(用户本地展开/收起偏好优先,见设置页 localStorage) */
+    collapsed: d.collapsed === true,
+    /** false = 不可折叠(始终展开;用于字段极少的固定分组) */
+    collapsible: d.collapsible !== false,
+    icon: d.icon ? String(d.icon) : '',
+    source,
+  }
+  if (order !== undefined) group.order = order
+  if (d.labelKey) group.labelKey = String(d.labelKey)
+  if (plugin) group.plugin = String(plugin)
+  return { ok: true, group }
+}
+
+function readFile(file) {
+  try {
+    const raw = JSON.parse(readFileSync(file, 'utf8'))
+    const list = Array.isArray(raw) ? raw : (Array.isArray(raw?.groups) ? raw.groups : [])
+    return list
+  }
+  catch {
+    return []
+  }
+}
+
+/** 原子写入(tmp + rename);Windows 上 rename 覆盖是原子的 */
+export function saveGroups(groups, groupsPath) {
+  mkdirSync(dirname(groupsPath), { recursive: true })
+  const payload = { version: 1, updatedAt: new Date().toISOString(), groups }
+  const tmp = `${groupsPath}.${process.pid}.tmp`
+  writeFileSync(tmp, `${JSON.stringify(payload, null, 2)}\n`, 'utf8')
+  renameSync(tmp, groupsPath)
+  return payload
+}
+
+export function readGroups(groupsPath) {
+  if (!existsSync(groupsPath)) return []
+  const out = []
+  for (const raw of readFile(groupsPath)) {
+    const n = normalizeGroup(raw, { source: raw?.source === 'user' ? 'user' : (raw?.source ?? 'user') })
+    if (n.ok) out.push(n.group)
+  }
+  return out
+}
+
+/**
+ * 由描述符推导内置分组的出现顺序(按 schema 声明顺序,首次出现的位置定序)。
+ * @returns {string[]} 去重后的 group id 列表
+ */
+export function builtinGroupOrder(descriptors = []) {
+  const seen = new Set()
+  const out = []
+  for (const d of descriptors) {
+    const g = String(d?.group ?? '').trim()
+    if (!g || seen.has(g)) continue
+    seen.add(g)
+    out.push(g)
+  }
+  return out
+}
+
+/**
+ * 合并三路来源 → 有序分组列表(唯一分组权威)。
+ *
+ * 覆盖优先级:plugin > persisted(user/用户定制) > builtin 默认。
+ *  · plugin 组每次装载以插件声明为准(插件改标题/排序即刻生效)
+ *  · builtin 组的标题/排序/折叠允许被 persisted 覆盖(管理员定制),但 source 恒为 builtin
+ *  · persisted 里 source=plugin 且本轮插件未声明的 → 摘除(插件卸载不残留)
+ *  · 描述符引用了未登记分组 → 兜底注册,字段不丢
+ *
+ * @param {object} o
+ * @param {Array} o.descriptors      全部描述符(全局 + 插件)
+ * @param {Array} o.persisted        持久化分组(含管理员定制)
+ * @param {Array} o.pluginGroups     本轮插件声明的分组
+ * @param {Map<string,string>} [o.pluginLabelById] 插件名 → 展示名(用于自动生成组标题)
+ */
+export function mergeGroups({ descriptors = [], persisted = [], pluginGroups = [], pluginLabelById = new Map() } = {}) {
+  const out = new Map()
+
+  // 1) 内置:声明顺序定序
+  const builtin = builtinGroupOrder(descriptors)
+  builtin.forEach((id, i) => {
+    out.set(id, {
+      id,
+      label: id,
+      description: '',
+      order: (i + 1) * 10,
+      collapsed: false,
+      collapsible: true,
+      icon: '',
+      source: 'builtin',
+    })
+  })
+
+  // 2) 持久化(管理员定制 + user 组);plugin 来源需等第 3 步确认存活
+  const persistedById = new Map()
+  for (const g of persisted) persistedById.set(g.id, g)
+
+  // 3) 插件声明(权威覆盖)
+  for (const g of pluginGroups) {
+    const merged = { ...(persistedById.get(g.id) ?? {}), ...g, source: 'plugin' }
+    const label = g.label && g.label !== g.id ? g.label : (pluginLabelById.get(g.plugin) ?? g.label)
+    out.set(g.id, { ...merged, label: label || g.id })
+  }
+
+  // 4) 持久化里非插件组的定制覆盖内置默认(order 缺省时保留内置声明顺序)
+  for (const [id, g] of persistedById) {
+    if (g.source === 'plugin') continue // 交给第 3 步/第 5 步裁决
+    const base = out.get(id)
+    const order = g.order !== undefined ? g.order : base?.order
+    if (base) {
+      out.set(id, { ...base, ...g, order, source: base.source })
+    }
+    else {
+      out.set(id, { ...g, order, source: g.source === 'user' ? 'user' : 'builtin' })
+    }
+  }
+
+  // 5) 摘除本轮未声明的 plugin 组(插件卸载/停用)
+  for (const [id, g] of out) {
+    if (g.source !== 'plugin') continue
+    const declared = pluginGroups.some(p => p.id === id) || builtin.includes(id)
+    if (!declared) out.delete(id)
+  }
+
+  // 6) 兜底:描述符引用了未登记分组 → 就地注册,保证字段有归属
+  builtin.forEach((id, i) => {
+    if (!out.has(id)) {
+      out.set(id, { id, label: id, description: '', order: (i + 1) * 10, collapsed: false, collapsible: true, icon: '', source: 'builtin' })
+    }
+  })
+
+  return [...out.values()].sort((a, b) => (a.order - b.order) || a.id.localeCompare(b.id))
+}
+
+/** 分组 id 的默认落盘路径(与 runtime-settings.json 同目录) */
+export function groupsPathFor(configRoot) {
+  return join(configRoot, GROUPS_FILENAME)
+}
+
+export default {
+  GROUPS_FILENAME,
+  pluginGroupId,
+  namespacedPluginGroupId,
+  defaultPluginGroupId,
+  normalizeGroup,
+  readGroups,
+  saveGroups,
+  builtinGroupOrder,
+  mergeGroups,
+  groupsPathFor,
+}

package/shared/config/home.mjs

@@ -129,6 +129,8 @@ export function resolveRunMode({ cwd, packageRoot, env = process.env } = {}) {
  *   > home 模式 ~/.AgentWorkShop/data > cwd/data 兜底)。
  * 启动器(scripts/start.mjs / dev-guard.mjs)会经 resolveRunMode 注入 AW_DATA_DIR;
  * 本函数为其兜底(直接 node .output/server/index.mjs 等无启动器场景)。
+ * cwd 显式传入 resolveRunMode:调用方给定了 cwd 就必须以它为准,否则
+ * ensureDataDir(cwd, env) 的迁移目标(cwd 内)与解析源(process.cwd())不一致。
  */
 export function dataDirFor(cwd = process.cwd(), env = process.env) {
   if (env.AW_DATA_DIR && String(env.AW_DATA_DIR).trim()) return resolve(String(env.AW_DATA_DIR).trim())
@@ -138,7 +140,8 @@ export function dataDirFor(cwd = process.cwd(), env = process.env) {
 
 /**
  * 确保数据目录存在，并把旧位置(cwd/data 与 cwd/server/data)的运行时文件
- * 迁入配置根（仅复制目标缺失的文件，不删除旧文件;幂等）。
+ * 迁入配置根。迁移采用「最新者胜」(newest-wins)：目标缺失时复制，或旧位置
+ * 副本严格新于目标时覆盖；目标更新或同时刻一律不覆盖。不删除旧文件;幂等。
  * 迁移覆盖 sqlite 主库/-wal/-shm 与 JSON 仓库文件;跳过 .tmp 临时产物。
  */
 export function ensureDataDir(cwd = process.cwd(), env = process.env) {
@@ -163,7 +166,13 @@ export function ensureDataDir(cwd = process.cwd(), env = process.env) {
       const src = join(legacy, f)
       const dst = join(dir, f)
       try {
-        if (!existsSync(dst) && statSync(src).isFile()) copyFileSync(src, dst)
+        if (!statSync(src).isFile()) continue
+        // 最新者胜(newest-wins)：历史实现只在目标缺失时复制，两处各存一份后
+        // 便永久分叉——旧位置继续被 cwd 相对路径的写入方更新，配置根却再无覆盖机会。
+        // 改为按 mtimeMs 比较：旧位置严格更新才覆盖，目标更新或同时刻保持不动，
+        // 因此两侧收敛到同一份(更新的)数据，且不会用陈旧副本倒退已迁移的库。
+        if (existsSync(dst) && statSync(src).mtimeMs <= statSync(dst).mtimeMs) continue
+        copyFileSync(src, dst)
       }
       catch { /* 单个文件迁移失败不阻断 */ }
     }