@fa-software/semi2-dsh 0.0.13 → 0.0.14-preview.20260922151653

package/lib/service/lifecycle.js

@@ -1,11 +1,9 @@
 import { clearConnection, connectionOf, storeConnection, } from '../hub/credentials.js';
 import { codeOf, ConfigurationError } from '../hub/errors.js';
 import { initialState } from '../hub/facts.js';
-import { installSections } from './settings-sections.js';
 import { appliedState, publishFailed, publishStatus } from './publish.js';
-import { readOwned, readWorkspaces } from './namespaces.js';
+import { readOwned, readWorkspaces, SEMI2_SETTINGS_ENTRY } from './namespaces.js';
 import { DOMAINS } from './registry.js';
-import { reportEvent } from './audit.js';
 import { connectionSnapshot, exchangeCnbCredential, resolveConnectionWithRetry, resolveContract, } from './connection.js';
 /** 首次加载；未配凭据或失败只落到 state.error，绝不 throw，也不注入任何配置。 */
 export async function start(engine) {
@@ -13,22 +11,14 @@ export async function start(engine) {
         const settings = await engine.ports.settings();
         engine.setSettings(settings);
         if (settings !== undefined) {
-            installSections(engine.ctx, settings, {
-                onSyncRequest: (value) => {
-                    // 带范围的同步：`workspace:<slug>` 只同步那一个工作区，其余整体重载。
-                    // 两条路都要回写状态：`sync` 是触发字段，只有复位成空串，下一次同名写入才算变更。
-                    if (value.startsWith('workspace:')) {
-                        void engine
-                            .workspace()
-                            .syncBySlug(value.slice('workspace:'.length))
-                            .then(() => publishStatus(engine));
-                        return;
-                    }
-                    void reload(engine);
-                },
-            });
+            // 状态段是展示面，不是给用户编辑的表单。
+            engine.ports.hideSettingsPage(settings, engine.ctx);
             // 上次的映射先恢复：headless 面无 dsh 工作区服务，这份本地事实就是全部列表。
-            engine.workspace().restore(readWorkspaces(settings));
+            // 读之前要等条目 ACTIVE——dsh 的 describe() 看不见还没激活的条目，读早了会把映射读成空。
+            if (await engine.ports.awaitNamespace(settings, SEMI2_SETTINGS_ENTRY))
+                engine.workspace().restore(readWorkspaces(settings));
+            else
+                engine.warn('设置段未就绪，未恢复上次的工作区映射');
         }
         await ensureContract(engine);
         engine.workspace().ensureImplicit();
@@ -39,20 +29,6 @@ export async function start(engine) {
         else
             await load(engine);
         await publishStatus(engine);
-        // 会话启动 = 首次配置领取成功；未配凭据 / 领取失败都不是「会话起来过」。
-        // NPC 面自己的会话起点由适配器上报（带触发事实），这里只覆盖另外两个 Web 面与宿主直跑。
-        if (engine.connection() !== null &&
-            engine.state().status === 'ready' &&
-            engine.contract()?.face !== 'npc')
-            await reportEvent(engine, {
-                action: 'SESSION_START',
-                outcome: 'SUCCESS',
-                detail: {
-                    platform: engine.platform,
-                    consoleUrl: engine.connection()?.url ?? null,
-                    identity: engine.state().identity?.username ?? null,
-                },
-            });
     }
     finally {
         engine.settle();
@@ -72,6 +48,24 @@ export async function reload(engine) {
     }
     return load(engine);
 }
+/**
+ * 界面「同步」动作：`workspace:<slug>` 只同步那一个工作区，其余（含空串）整体重载。
+ * 两条路都把结果回写状态段；失败只 warn（面板上的错误由状态字段承载）。
+ */
+export async function syncByScope(engine, scope) {
+    try {
+        if (scope.startsWith('workspace:')) {
+            await engine.workspace().syncBySlug(scope.slice('workspace:'.length));
+            await publishStatus(engine);
+            return;
+        }
+        await reload(engine);
+    }
+    catch (error) {
+        engine.warn(`同步失败（${codeOf(error)}）`);
+        await publishStatus(engine);
+    }
+}
 /** 读取一次运行配置；整体失败只落 state.error，绝不 throw（start/reload 均可重试）。 */
 export async function load(engine) {
     engine.patchState({ status: 'loading', error: null });
@@ -108,6 +102,9 @@ async function applyBoot(engine, boot, errorCode) {
         engine.markSettingsMissing();
     let compiled = null;
     if (settings !== undefined) {
+        // 归属表读的是自身设置段：条目还没 ACTIVE 时 describe() 看不见它，读早了会当成「上次没注入过」。
+        if (!(await engine.ports.awaitNamespace(settings, SEMI2_SETTINGS_ENTRY)))
+            engine.warn('设置段未就绪，本轮按「上次无注入记录」继续');
         const previousOwned = readOwned(settings);
         const run = {
             boot,
@@ -131,7 +128,7 @@ async function applyBoot(engine, boot, errorCode) {
         compiled = run.compiled;
         // 归属表 = 本轮实际写入的事实；某领域降级时保持上次的值（不动即不回收）。
         try {
-            await engine.ports.updateNamespace(settings, 'semi2-providers', { ...run.owned });
+            await engine.ports.updateNamespace(settings, SEMI2_SETTINGS_ENTRY, { ...run.owned });
         }
         catch (error) {
             failures.push(engine.noteFailure('注入归属表', error));
@@ -209,10 +206,11 @@ async function reclaim(engine) {
                 engine.warn(`领域 ${descriptor.id} 回收失败（${codeOf(error)}）`);
             }
         }
-        await engine.ports.updateNamespace(settings, 'semi2-providers', {
+        await engine.ports.updateNamespace(settings, SEMI2_SETTINGS_ENTRY, {
             routes: [],
             credentials: [],
             deepseek: false,
+            deepseekSearchKeyEnv: '',
         });
     }
     catch (error) {

package/lib/service/namespaces.js

@@ -1,20 +1,34 @@
-// @fa-software/semi2-dsh/service/namespaces —— 本插件三个设置命名空间的名字与读取（无环叶子模块）。
-// 归属表与工作区映射是「插件自己写、自己读」的内部事实，用户不编辑；单列命名空间是因为
-// `semi2` 由 publishStatus 走 replace 整体覆盖，混进去会在每次状态回报时被冲掉。
+// @fa-software/semi2-dsh/service/namespaces —— 插件自身设置段的字段与读取（无环叶子模块）。
+// dsh 的设置段 = Profile 插件条目，一个条目只有一段：状态 / 健康 / 工作区 tab / 归属表 / 工作区映射
+// 同住 `SEMI2_SETTINGS_ENTRY` 这一段，各写各的键（写入是合并，谁也不冲掉谁）。
 import z from '@deepseek-ai/schemastery';
-/** 侧栏 Semi2 主页面的命名空间：sync 由 UI 写（触发重载），状态字段由本插件写（展示）。 */
-export const SETTINGS_NAMESPACE = 'semi2';
-/** 归属表：预设连接的路由键就是 dsh 的提供方 id，光看名字分不清是插件的还是用户手写的 profile。 */
-export const OWNED_NAMESPACE = 'semi2-providers';
-/** 工作区 → git 项目映射的持久化命名空间：本地事实（换台机器要重解析），只存目录与解析结果。 */
-export const WORKSPACES_NAMESPACE = 'semi2-workspaces';
-export const OWNED_SCHEMA = z.object({
+import { SEMI2_SETTINGS_ENTRY } from '../contract.js';
+export { SEMI2_SETTINGS_ENTRY };
+/**
+ * 归属表字段：预设注入的路由与密钥引用。
+ * 「上次注入的条目」与「用户自己写的同名条目」无法从名字分辨，这份账本是唯一依据。
+ */
+export const OWNED_FIELDS = {
     routes: z.array(z.string()).default([]),
     credentials: z.array(z.string()).default([]),
     deepseek: z.boolean().default(false),
-});
-/** 一个命名空间的当前有效段：官方描述符的 `value` 是不透明值，本插件只认对象段，其余按空段处理。 */
-export function sectionValue(settings, ns) {
+    deepseekSearchKeyEnv: z.string().default(''),
+};
+/** 工作区 → git 项目映射的字段：本地事实（换台机器要重解析），只存目录与解析结果。 */
+export const WORKSPACES_FIELDS = {
+    entries: z
+        .array(z.object({
+        path: z.string().default(''),
+        title: z.string().default(''),
+        slug: z.string().default(''),
+        projectId: z.string().default(''),
+        name: z.string().default(''),
+        syncedAt: z.string().default(''),
+    }))
+        .default([]),
+};
+/** 一个设置段的当前有效值：官方描述符的 `value` 是不透明值，本插件只认对象段，其余按空段处理。 */
+export function sectionValue(settings, ns = SEMI2_SETTINGS_ENTRY) {
     const value = settings.describe().find(entry => entry.ns === ns)?.value;
     return value !== null && typeof value === 'object' && !Array.isArray(value)
         ? value
@@ -25,12 +39,28 @@ function stringsOf(input) {
         ? input.filter((item) => typeof item === 'string')
         : [];
 }
+/** 本插件自铸的密钥引用名（`connectionApiKeyEnv` 的形状）：账本丢了也认得出「这是我们写过的键」。 */
+const OWNED_KEY_ENV = /^SEMI2_MODEL_KEY_[\dA-F]+$/;
+/** 官方段里留着的自铸引用 = 上一轮注入的痕迹（该段的值在，账本不在）。 */
+function ownedKeyEnvOf(settings, ns) {
+    const value = sectionValue(settings, ns).apiKeyEnv;
+    return typeof value === 'string' && OWNED_KEY_ENV.test(value) ? value : null;
+}
+/**
+ * 本插件写过什么的账本；账本缺失（升级时旧设置段迁不进来、或换了台机器）时按自铸引用名认领：
+ * 认领只会多回收自己写过的东西，不会碰用户手写的段。
+ */
 export function readOwned(settings) {
-    const value = sectionValue(settings, OWNED_NAMESPACE);
+    const value = sectionValue(settings);
+    const deepseekSearchKeyEnv = typeof value.deepseekSearchKeyEnv === 'string' &&
+        value.deepseekSearchKeyEnv !== ''
+        ? value.deepseekSearchKeyEnv
+        : null;
     return {
         routes: stringsOf(value.routes),
         credentials: stringsOf(value.credentials),
-        deepseek: value.deepseek === true,
+        deepseek: value.deepseek === true || ownedKeyEnvOf(settings, 'llm-deepseek') !== null,
+        deepseekSearchKeyEnv: deepseekSearchKeyEnv ?? ownedKeyEnvOf(settings, 'web-search-deepseek'),
     };
 }
 function text(value) {
@@ -39,7 +69,7 @@ function text(value) {
 }
 /** 持久化段 → 工作区条目；形状不合的行直接丢弃，不让坏数据拖垮启动。 */
 export function readWorkspaces(settings) {
-    const value = sectionValue(settings, WORKSPACES_NAMESPACE);
+    const value = sectionValue(settings);
     const rows = Array.isArray(value.entries) ? value.entries : [];
     const entries = [];
     for (const row of rows) {

package/lib/service/ports.js

@@ -2,7 +2,7 @@ import { setTimeout as delay } from 'node:timers/promises';
 import { ConfigurationError } from '../hub/errors.js';
 const SETTINGS_TIMEOUT_MS = 5_000;
 const NAMESPACE_WAIT_MS = 2_000;
-/** 命名空间注册轮询间隔（纯内部预算，不单列到 Config）。 */
+/** 设置段就绪轮询间隔（纯内部预算，不单列到 Config）。 */
 const NAMESPACE_POLL_MS = 50;
 export function createPorts(ctx, warn, options = {}) {
     const settingsTimeoutMs = options.settingsTimeoutMs ?? SETTINGS_TIMEOUT_MS;
@@ -28,14 +28,20 @@ export function createPorts(ctx, warn, options = {}) {
         credentialsNow: () => ctx.get('credentials', false),
         agentDefaultModel: () => ctx.get('agentDefaultModel', false),
         hasWorkspaceController: () => ctx.get('workspaceController', false) !== undefined,
-        updateNamespace: (settings, ns, patch) => writeNamespace(settings, ns, () => settings.update(ns, patch), namespaceWaitMs),
-        replaceNamespace: (settings, ns, section) => {
+        awaitNamespace: (settings, ns) => waitForNamespace(settings, ns, namespaceWaitMs),
+        updateNamespace: async (settings, ns, patch) => {
+            await requireNamespace(settings, ns, namespaceWaitMs);
+            await settings.update(ns, patch);
+        },
+        replaceNamespace: async (settings, ns, section) => {
+            await requireNamespace(settings, ns, namespaceWaitMs);
             const replace = settings.replace?.bind(settings);
             if (replace === undefined) {
                 warn(`宿主 settings 无 replace，${ns} 退回合并写入：服务端已撤下的条目可能残留`);
-                return writeNamespace(settings, ns, () => settings.update(ns, section), namespaceWaitMs);
+                await settings.update(ns, section);
+                return;
             }
-            return writeNamespace(settings, ns, () => replace(ns, section), namespaceWaitMs);
+            await replace(ns, section);
         },
         clearKeys: async (settings, ns, keys) => {
             const mutate = settings.mutate?.bind(settings);
@@ -43,22 +49,39 @@ export function createPorts(ctx, warn, options = {}) {
                 warn(`宿主 settings 无 mutate，${ns} 无法按路径删除：服务端已撤销的覆盖可能残留`);
                 return;
             }
+            await requireNamespace(settings, ns, namespaceWaitMs);
             const ops = keys.map(key => ({ op: 'unset', path: [key] }));
-            await writeNamespace(settings, ns, () => mutate(ns, ops), namespaceWaitMs);
+            await mutate(ns, ops);
+        },
+        hideSettingsPage: (settings, owner) => {
+            const configure = settings.configure?.bind(settings);
+            if (configure === undefined)
+                return;
+            try {
+                // 回收器挂在本插件光纤上：插件卸载后不留一条指向已死光纤的展示策略。
+                const dispose = configure({ auto: false }, owner.fiber);
+                owner.effect(() => dispose);
+            }
+            catch (error) {
+                warn(`设置页自动生成关闭失败（${error instanceof Error ? error.message : String(error)}）`);
+            }
         },
     };
 }
-/** 等命名空间注册完成再写（settings 服务与各 bundle 的注册有先后）；写失败原样上抛由调用方降级。 */
-async function writeNamespace(settings, ns, write, waitMs) {
+/** 等设置段可描述（条目 ACTIVE 且声明了 volatile 字段）；超时返回 false，不抛。 */
+async function waitForNamespace(settings, ns, waitMs) {
     const deadline = Date.now() + waitMs;
     for (;;) {
-        if (settings.describe().some(entry => entry.ns === ns)) {
-            await write();
-            return;
-        }
+        if (settings.describe().some(entry => entry.ns === ns))
+            return true;
         if (Date.now() >= deadline)
-            break;
+            return false;
         await delay(NAMESPACE_POLL_MS);
     }
+}
+/** 写路径的就绪门：条目还不可描述就拒绝，由调用方降级（不静默写进空气）。 */
+async function requireNamespace(settings, ns, waitMs) {
+    if (await waitForNamespace(settings, ns, waitMs))
+        return;
     throw new ConfigurationError('CONFIG_APPLY_FAILED');
 }

package/lib/service/publish.js

@@ -1,10 +1,14 @@
 import { statusFields, workspaceTabs, WORKSPACE_TABS_FIELD, } from '../hub/status.js';
-import { SYNC_FIELD } from './settings-sections.js';
-import { SETTINGS_NAMESPACE } from './namespaces.js';
+import { SEMI2_SETTINGS_ENTRY } from './namespaces.js';
 import { aggregateHealth, healthText } from './health.js';
 import { DOMAINS } from './registry.js';
 import { reportEvent } from './audit.js';
-/** 状态 + 健康 + 工作区 tab 一次写回（权威 replace；sync 字段复位为空，无令牌比对）。 */
+/**
+ * 状态 + 健康 + 工作区 tab 一次写回。
+ *
+ * 用合并写入而不是 `replace`：这一段落里还有归属表与工作区映射，`replace` 会把它们一起重置。
+ * 状态字段名是编译期常量集合，合并写入不存在「服务端撤下的条目残留」问题。
+ */
 export async function publishStatus(engine) {
     const settings = engine.settings();
     if (settings === undefined)
@@ -29,13 +33,9 @@ export async function publishStatus(engine) {
             `${item.state}:${healthText(item)}`,
         ])),
         [WORKSPACE_TABS_FIELD]: workspaceTabs(engine.state()),
-        [SYNC_FIELD]: '',
     };
     try {
-        if (settings.replace !== undefined)
-            await settings.replace(SETTINGS_NAMESPACE, section);
-        else
-            await settings.update(SETTINGS_NAMESPACE, section);
+        await engine.ports.updateNamespace(settings, SEMI2_SETTINGS_ENTRY, section);
     }
     catch {
         engine.warn('设置页状态写入失败');

package/lib/service/registry.js

@@ -1,5 +1,6 @@
 import { defaultModelDomain } from '../domains/default-model/index.js';
 import { modelsDomain } from '../domains/models/index.js';
+import { redmineDomain } from '../domains/redmine/index.js';
 import { secretsDomain } from '../domains/secrets/index.js';
 import { selfPortraitDomain } from '../domains/self-portrait/index.js';
 import { skillsDomain } from '../domains/skills/index.js';
@@ -12,4 +13,5 @@ export const DOMAINS = [
     workspaceDomain,
     defaultModelDomain,
     selfPortraitDomain,
+    redmineDomain,
 ];

package/lib/service/sessions.js

@@ -0,0 +1,90 @@
+// @fa-software/semi2-dsh/service/sessions —— dsh 会话生命周期上报：一次会话一行。
+// 只报顶层会话（子 agent 的会话跳过）；dsh-session 服务缺席或上报失败都只 warn 降级，
+// 会话照跑——hub 的客户端会话日志是旁路事实，不是会话的前提。
+import { randomUUID } from 'node:crypto';
+import { canonicalPath } from '../hub/workspace-book.js';
+import { reportEvent } from './audit.js';
+/**
+ * 本面实例标识：同名 dsh 会话（`session-1`）在不同容器里会撞车，hub 靠它分开。
+ * 每次进程启动生成一个，进程内所有会话共用。
+ */
+const CLIENT_ID = randomUUID();
+/** 子 agent 的会话不是「用户开的会话」：不建行、不计数。 */
+function isUserSession(session) {
+    return session.header.origin !== 'subagent';
+}
+/**
+ * 会话归属：cwd 命中的已登记工作区给 slug，项目由工作区领域按 cwd 解析。
+ * 拿不到就是拿不到（不落占位值）——headless 面没有工作区服务时也走这条。
+ */
+async function scopeOf(engine, cwd) {
+    const directory = cwd?.trim() ?? '';
+    if (directory === '')
+        return { workspacePath: null, workspaceSlug: null, projectSlug: null };
+    const canonical = await canonicalPath(directory);
+    const entry = engine
+        .workspace()
+        .tracked()
+        .find(item => item.path === canonical);
+    const project = await engine.peer('workspace')?.projectForCwd(canonical);
+    return {
+        workspacePath: canonical,
+        workspaceSlug: entry?.slug ?? null,
+        projectSlug: project?.slug ?? null,
+    };
+}
+/** 会话创建：带上工作区与默认模型选择，hub 据此建行。 */
+async function reportCreated(engine, session) {
+    const scope = await scopeOf(engine, session.header.cwd);
+    const selection = engine.ctx.get('agentDefaultModel', false)?.currentSelection?.();
+    await reportEvent(engine, {
+        action: 'SESSION_CREATED',
+        outcome: 'SUCCESS',
+        code: 'created',
+        sessionId: session.id,
+        clientId: CLIENT_ID,
+        ...(scope.workspacePath === null ? {} : { workspacePath: scope.workspacePath }),
+        ...(scope.workspaceSlug === null ? {} : { workspaceSlug: scope.workspaceSlug }),
+        ...(scope.projectSlug === null ? {} : { projectSlug: scope.projectSlug }),
+        ...(selection?.model === undefined || selection.model === ''
+            ? {}
+            : { modelId: selection.model }),
+        ...(selection?.reasoningEffort === undefined ||
+            selection.reasoningEffort === ''
+            ? {}
+            : { reasoningLevel: selection.reasoningEffort }),
+        detail: { cwd: scope.workspacePath },
+    });
+}
+/** 会话销毁：回填结束时间与原因码；进程被强杀时没有这一条（页面显示「无结束行」）。 */
+async function reportDisposed(engine, session) {
+    await reportEvent(engine, {
+        action: 'SESSION_DISPOSED',
+        outcome: 'SUCCESS',
+        code: 'dispose',
+        sessionId: session.id,
+        clientId: CLIENT_ID,
+    });
+}
+/**
+ * 挂上会话订阅：dsh 的会话是事件源的（`session/created` / `session/disposed`），
+ * 本插件只旁听，不改会话行为。`sessions` 服务缺席时整块跳过。
+ * 返回订阅光纤（可 await 到就绪），测试据它确认监听已挂上。
+ */
+export function installSessionReporting(engine, ctx = engine.ctx) {
+    return ctx.inject(['sessions'], (scoped) => {
+        const track = (session, report) => {
+            if (!isUserSession(session))
+                return;
+            void report(engine, session).catch((error) => {
+                engine.warn(`会话上报失败：${error instanceof Error ? error.message : String(error)}`);
+            });
+        };
+        scoped.on('session/created', (session) => {
+            track(session, reportCreated);
+        });
+        scoped.on('session/disposed', (session) => {
+            track(session, reportDisposed);
+        });
+    });
+}

package/lib/service/settings-sections.js

@@ -1,29 +1,22 @@
-// @fa-software/semi2-dsh/service/settings-sections —— 三个设置命名空间的声明与读写（按注册表聚合生成）。
-// `semi2` 面向用户（状态由本插件写、sync 由 UI 写触发重载）；另两个是内部事实（用户不编辑）。
+// @fa-software/semi2-dsh/service/settings-sections —— 插件自身设置段的字段声明（按注册表聚合生成）。
+// dsh 的设置段 = Profile 插件条目（id = `SEMI2_SETTINGS_ENTRY`）：只有声明为 volatile 的字段才会被
+// `describe()` 看见、才能实时写入，所以状态 / 健康 / 工作区 tab / 归属表 / 工作区映射全部在这里声明；
+// 数值旋钮不在此列——它们是加载期参数，改动理应重挂载。
 import z from '@deepseek-ai/schemastery';
 import { STATUS_BASE_FIELDS, WORKSPACE_TABS_FIELD } from '../hub/status.js';
+import { OWNED_FIELDS, WORKSPACES_FIELDS } from './namespaces.js';
 import { DOMAINS } from './registry.js';
-import { OWNED_NAMESPACE, OWNED_SCHEMA, sectionValue, SETTINGS_NAMESPACE, WORKSPACES_NAMESPACE, } from './namespaces.js';
-/** UI 触发重载的字段：写入任意非空值即触发（写后由状态回报复位为空，无令牌比对）。 */
-export const SYNC_FIELD = 'sync';
-/** 完整状态字段顺序（基座 + 按注册表顺序的领域字段）；UI 与健康字段共用命名空间。 */
+/** 完整状态字段顺序（基座 + 按注册表顺序的领域字段）；UI 与健康字段共用这一段。 */
 export const STATUS_FIELDS = [
     ...STATUS_BASE_FIELDS,
     ...DOMAINS.flatMap(domain => [...domain.statusKeys]),
 ];
-/** 工作区映射的 settings schema（空值统一落空串，读侧再归一为 null）。 */
-const WORKSPACES_SCHEMA = z.object({
-    entries: z
-        .array(z.object({
-        path: z.string().default(''),
-        title: z.string().default(''),
-        slug: z.string().default(''),
-        projectId: z.string().default(''),
-        name: z.string().default(''),
-        syncedAt: z.string().default(''),
-    }))
-        .default([]),
-});
+/** 健康字段 schema 键（能力 + 领域，值是 `ok:正常` 形式的编码串；读侧拆码）。 */
+export const HEALTH_FIELDS_SCHEMA_KEYS = [
+    'healthWeb',
+    'healthCodegraph',
+    ...DOMAINS.map(domain => `health:${domain.id}`),
+];
 /** tab 列表字段：结构化数组（界面按作用域渲染用；扁平字符串继续留给纯文本展示）。 */
 const WORKSPACE_TABS_SCHEMA = z.array(z.object({
     slug: z.string().default(''),
@@ -32,47 +25,15 @@ const WORKSPACE_TABS_SCHEMA = z.array(z.object({
     project: z.string().default(''),
     syncedAt: z.string().default(''),
     implicit: z.boolean().default(false),
-})).default([]);
-/** 健康字段 schema（能力 + 领域，值是 `ok:正常` 形式的编码串；读侧拆码）。 */
-export const HEALTH_FIELDS_SCHEMA_KEYS = [
-    'healthWeb',
-    'healthCodegraph',
-    ...DOMAINS.map(domain => `health:${domain.id}`),
-];
-const STATUS_SCHEMA = Object.fromEntries([...STATUS_FIELDS, ...HEALTH_FIELDS_SCHEMA_KEYS].map(key => [key, z.string().default('')]));
-/** 安装三个命名空间；只在拿到 settings 服务后调用一次。 */
-export function installSections(ctx, settings, hooks) {
-    settings.installSection(ctx, SETTINGS_NAMESPACE, z.object({
-        [SYNC_FIELD]: z.string().default(''),
-        ...STATUS_SCHEMA,
-        [WORKSPACE_TABS_FIELD]: WORKSPACE_TABS_SCHEMA,
-    }), {
-        ...Object.fromEntries([SYNC_FIELD, ...STATUS_FIELDS, ...HEALTH_FIELDS_SCHEMA_KEYS].map(key => [key, ''])),
-        [WORKSPACE_TABS_FIELD]: [],
-    }, {
-        setSource: () => { },
-        onChange: () => {
-            // 用户写入才会走到这里；读有效值判断是否 sync 触发（本插件自己的 replace 也会触发 onChange，
-            // 但回报时 sync 恒写空串，不会成环）。
-            const value = sectionValue(settings, SETTINGS_NAMESPACE)[SYNC_FIELD];
-            if (typeof value === 'string' && value !== '')
-                hooks.onSyncRequest(value);
-        },
-    });
-    // 归属表由插件自己写、自己读，不暴露给用户；没有它就无法区分
-    // 「上次注入的条目」与「用户自己写的同名条目」。
-    settings.installSection(ctx, OWNED_NAMESPACE, OWNED_SCHEMA, {
-        routes: [],
-        credentials: [],
-        deepseek: false,
-    }, { setSource: () => { }, onChange: () => { } });
-    // 工作区映射同理：纯本地事实，用户不编辑（工作区增删在 dsh 自己的工作区面板）。
-    settings.installSection(ctx, WORKSPACES_NAMESPACE, WORKSPACES_SCHEMA, {
-        entries: [],
-    }, { setSource: () => { }, onChange: () => { } });
-}
-/** 读 `semi2` 命名空间的一个字段（用户写入后、回报前的过渡值）。 */
-export function readSetting(settings, key) {
-    const value = sectionValue(settings, SETTINGS_NAMESPACE)[key];
-    return typeof value === 'string' ? value : '';
+}));
+/** 一个字段表 → 全部置 volatile（整体一个可实时写的节点，子路径共用该性质）。 */
+function allVolatile(fields) {
+    return Object.fromEntries(Object.entries(fields).map(([key, field]) => [key, field.volatile()]));
 }
+/** 插件 Config 的可写字段表（并入入口的 Config schema）。 */
+export const STATE_CONFIG_FIELDS = {
+    ...allVolatile(Object.fromEntries([...STATUS_FIELDS, ...HEALTH_FIELDS_SCHEMA_KEYS].map(key => [key, z.string().default('')]))),
+    [WORKSPACE_TABS_FIELD]: WORKSPACE_TABS_SCHEMA.default([]).volatile(),
+    ...allVolatile(OWNED_FIELDS),
+    ...allVolatile(WORKSPACES_FIELDS),
+};

package/lib/types/api/generated/documents.d.ts

@@ -1,5 +1,5 @@
 /** 启动装配：五个用户级领域一个文档（项目绑定按工作区另行按需取）。 */
-export declare const RUNTIME_BOOT_DOCUMENT = "query RuntimeBoot {\n  runtimeViewer {\n    id\n    username\n    displayName\n  }\n  runtimeModels {\n    id\n    upstreamId\n    displayName\n    metadata { contextWindow maxTokens input reasoningLevels }\n    defaultReasoningLevel\n    connection { id provider protocol baseUrl }\n  }\n  runtimeDefaultModelId\n  runtimeHeadlessModels {\n    planModelId\n    executeModelId\n  }\n  runtimeModelCredentials {\n    connectionId\n    value\n  }\n  runtimeSkills {\n    id\n    projectId\n    name\n    description\n    whenToUse\n    content\n    version\n    files {\n      path\n      sizeBytes\n      mimeType\n      isExecutable\n    }\n    fileCount\n    filesBytes\n  }\n  runtimeSelfPortrait\n}";
+export declare const RUNTIME_BOOT_DOCUMENT = "query RuntimeBoot {\n  runtimeViewer {\n    id\n    username\n    displayName\n  }\n  runtimeModels {\n    id\n    upstreamId\n    displayName\n    metadata { contextWindow maxTokens input reasoningLevels }\n    defaultReasoningLevel\n    connection { id provider protocol baseUrl }\n  }\n  runtimeDefaultModelId\n  runtimeHeadlessModels {\n    planModelId\n    executeModelId\n  }\n  runtimeModelCredentials {\n    connectionId\n    value\n  }\n  runtimeSkillCatalog {\n    id\n    projectId\n    name\n    description\n    whenToUse\n    invocation {\n      modelInvocable\n      userInvocable\n    }\n    metadata\n    content\n    version\n    files {\n      path\n      sizeBytes\n      mimeType\n      isExecutable\n    }\n    fileCount\n    filesBytes\n  }\n  runtimeSelfPortrait\n  runtimeRedmine {\n    baseUrl\n    apiKey\n  }\n}";
 /** 技能附属资源字节：boot 文档只带清单，真正加载某个技能时才按需取这一条。可空根字段：读取者不可见 / 不存在回空数组（权威「没有」），领域失败回 null（降级，不物化）。 */
 export declare const RUNTIME_SKILL_FILES_DOCUMENT = "query RuntimeSkillFiles($skillId: ID!) {\n  runtimeSkillFiles(skillId: $skillId) {\n    path\n    content\n    encoding\n    sizeBytes\n    mimeType\n    isExecutable\n  }\n}";
 /** 项目绑定按 slug 取：只问已登记工作区命中的那几个项目，绝不把整张项目表拉回本地。`slugs` 是读范围之上的过滤（不是绕过），空数组 = 空集合。 */

package/lib/types/api/generated/graphql.d.ts

@@ -14,21 +14,34 @@ export type InputModality = 'IMAGE' | 'TEXT';
 export type ModelProtocol = 'ANTHROPIC' | 'DEEPSEEK' | 'OPENAI_CHAT' | 'OPENAI_RESPONSES';
 export type ReasoningLevel = 'HIGH' | 'LOW' | 'MAX' | 'MEDIUM' | 'MINIMAL' | 'OFF' | 'XHIGH';
 /** 运行面可上报的动作：会话启停、拒绝、交付分支与交付核对。 */
-export type RuntimeEventAction = 'DELIVERY_READY' | 'DELIVERY_VERIFIED' | 'SESSION_END' | 'SESSION_FAILED' | 'SESSION_REFUSED' | 'SESSION_START';
+export type RuntimeEventAction = 'DELIVERY_READY' | 'DELIVERY_VERIFIED' | 'SESSION_CREATED' | 'SESSION_DISPOSED' | 'SESSION_FAILED' | 'SESSION_REFUSED' | 'SESSION_START';
 /**
  * 运行面上报：只接受用户密钥身份，动作码限闭集；detail 由服务端脱敏后落库。
- * 目标项目按 slug 解析：命中可读项目时 targetId 是项目 id，否则只留 slug 快照。
+ * 目标项目按 slug 解析：命中可读项目时挂项目 id，否则只留 slug 快照。
+ * 带会话身份（runRef 或 sessionId + clientId）的事件会折叠进同一行客户端会话。
  */
 export type RuntimeEventInput = {
     action: RuntimeEventAction;
-    /** 原因码 / 交付状态码（例 SETUP_FAILED、delivered）。 */
+    /** 运行面实例标识（插件进程内生成）：同名 dsh 会话在不同容器里靠它分开。 */
+    clientId?: string | null | undefined;
+    /** 原因码 / 交付状态码（例 SETUP_FAILED、delivered、dispose）。 */
     code?: string | null | undefined;
     detail?: unknown;
+    /** 会话使用的模型与档位（拿不到留空）。 */
+    modelId?: string | null | undefined;
     outcome: AuditOutcome;
-    /** 项目 slug（CNB 仓库 slug 或工作区目录名），用于把事件挂到项目上。 */
+    /** 项目 slug（CNB 仓库 slug 或已登记工作区 slug），用于把事件挂到项目上。 */
     projectSlug?: string | null | undefined;
+    reasoningLevel?: string | null | undefined;
+    /** 任务引用 `<repo>#<issue|pr>#<iid>`：NPC 一次任务的稳定身份，会话尚未创建也带。 */
+    runRef?: string | null | undefined;
+    /** dsh 会话 id（会话创建 / 销毁事件给出）。 */
+    sessionId?: string | null | undefined;
     /** 目标展示名（例 `issue-12` / `PR #34`）。 */
     targetLabel?: string | null | undefined;
+    /** 本次会话的 cwd 与命中的已登记工作区 slug。 */
+    workspacePath?: string | null | undefined;
+    workspaceSlug?: string | null | undefined;
 };
 /** 技能附件内容的编码：文本类用 UTF8，其余（图片 / 二进制）用 BASE64。 */
 export type SkillFileEncoding = 'BASE64' | 'UTF8';
@@ -69,16 +82,21 @@ export type RuntimeBootQuery = {
         connectionId: string;
         value: string;
     }> | null;
-    runtimeSkills: Array<{
+    runtimeSkillCatalog: Array<{
         id: string;
         projectId: string | null;
         name: string;
         description: string;
         whenToUse: string | null;
+        metadata: unknown;
         content: string;
         version: number;
         fileCount: number;
         filesBytes: number;
+        invocation: {
+            modelInvocable: boolean;
+            userInvocable: boolean;
+        };
         files: Array<{
             path: string;
             sizeBytes: number;
@@ -86,6 +104,10 @@ export type RuntimeBootQuery = {
             isExecutable: boolean;
         }>;
     }> | null;
+    runtimeRedmine: {
+        baseUrl: string | null;
+        apiKey: string | null;
+    } | null;
 };
 export type RuntimeSkillFilesQueryVariables = Exact<{
     skillId: string | number;