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

package/lib/contract.js

@@ -10,6 +10,12 @@ export const SEMI2_SECTION_ORDERS = {
     npcContract: 2,
     cnbWorkstation: 3,
 };
+/**
+ * 插件自身设置段的条目 id：dsh 的设置命名空间就是 Profile 插件条目 id（bundle patch 里那一行的 id），
+ * 状态 / 健康 / 归属表 / 工作区映射都写在这一段里。host 与浏览器半边共用这一个常量
+ * （`cordis.patch.yml` 的插件行 id 必须与它一致，`test/dsh/unit/profile-patch.test.mjs` 对账）。
+ */
+export const SEMI2_SETTINGS_ENTRY = 'semi2-dsh';
 /** 官方人设前缀段名（号段基准）；服务不认这个名字时按 0 兜底。 */
 const PERSONA_PREFIX_ORDER_NAME = 'DEPLOYMENT_PERSONA_PREFIX';
 /** 段的绝对位置 = 官方 persona 段号 + 本表偏移（服务缺席 / 不认名字时以偏移值兜底）。 */

package/lib/domains/models/domain.js

@@ -1,7 +1,10 @@
 import { compileBoot, connectionRoute, providerProfile, remapSelections, } from '../../hub/compile.js';
 import { sectionValue } from '../../service/namespaces.js';
+import { reclaimWebSearchKeyEnv, syncWebSearchKeyEnv } from './web-search.js';
 /** 自铸路由的键形状（semi2-<32 hex>）：归属表里没有记录时按名字兜底认领。 */
 const LEGACY_OWNED_PROVIDER = /^semi2-[\da-f]{32}$/;
+/** 本插件自铸的密钥引用名（`connectionApiKeyEnv` 的形状）：账本丢了也能按它认领注入过的路由。 */
+const OWNED_KEY_ENV = /^SEMI2_MODEL_KEY_[\dA-F]+$/;
 /** 本插件在 `llm-deepseek` 段写过的键：撤销只删这几个，不碰同段里用户自己加的键。 */
 export const DEEPSEEK_OWNED_KEYS = ['apiKeyEnv', 'baseURL', 'models'];
 /** 从既有 provider profile 上取密钥引用名（回收归属表外的自铸路由时连带清理其密钥）。 */
@@ -44,6 +47,7 @@ export class ModelsDomain {
             });
         else if (run.owned.deepseek)
             await this.host.ports.clearKeys(run.settings, 'llm-deepseek', DEEPSEEK_OWNED_KEYS);
+        await syncWebSearchKeyEnv(this.host, run, remapped.deepseek);
         run.compiled = remapped;
         run.owned = {
             ...run.owned,
@@ -59,6 +63,7 @@ export class ModelsDomain {
         const { staleCredentials } = await this.applyProviders(run.settings, {}, run.owned);
         if (run.owned.deepseek)
             await this.host.ports.clearKeys(run.settings, 'llm-deepseek', DEEPSEEK_OWNED_KEYS);
+        await reclaimWebSearchKeyEnv(this.host, run);
         run.staleCredentials = staleCredentials;
         this.compiled = null;
     }
@@ -102,15 +107,17 @@ export class ModelsDomain {
             injected[fallback] = providerProfile({ ...provider, preset: false });
             routes.set(route, fallback);
         }
-        // 归属表外的自铸路由一并回收，避免留下死路由（重载与登出都走这里）。
-        // 它们的密钥引用只能从被丢弃的 profile 上取——归属表里没有这条记录。
+        // 归属表外的自有路由一并回收，避免留下死路由（重载与登出都走这里）：名字是自铸形（semi2-<hex>），
+        // 或 profile 上的密钥引用是本插件自铸的（账本丢了也能认领）。密钥引用只能从这里取——账本里没有这条记录。
         const staleCredentials = [];
         const kept = Object.fromEntries(Object.entries(existing).filter(([id, profile]) => {
             if (owned.has(id))
                 return false;
-            if (!LEGACY_OWNED_PROVIDER.test(id))
-                return true;
             const env = apiKeyEnvOf(profile);
+            const ours = LEGACY_OWNED_PROVIDER.test(id) ||
+                (env !== undefined && OWNED_KEY_ENV.test(env));
+            if (!ours)
+                return true;
             if (env !== undefined)
                 staleCredentials.push(env);
             return false;

package/lib/domains/models/web-search.js

@@ -0,0 +1,61 @@
+import { sectionValue } from '../../service/namespaces.js';
+const WEB_SEARCH_DEEPSEEK_NAMESPACE = 'web-search-deepseek';
+const WEB_SEARCH_API_KEY_ENV_KEY = 'apiKeyEnv';
+const DEFAULT_DEEPSEEK_SEARCH_KEY_ENV = 'DEEPSEEK_API_KEY';
+/**
+ * 官方搜索默认解析 `DEEPSEEK_API_KEY`，而 hub 下发的是连接级引用；这里只对齐引用，
+ * 搜索端点与其他搜索配置仍归本地配置的所有者。
+ */
+export async function syncWebSearchKeyEnv(host, run, deepseek) {
+    const previous = run.previousOwned.deepseekSearchKeyEnv;
+    const current = webSearchKeyEnvOf(run.settings);
+    try {
+        if (deepseek !== null) {
+            const userOwned = current !== undefined &&
+                current !== previous &&
+                current !== DEFAULT_DEEPSEEK_SEARCH_KEY_ENV;
+            if (userOwned) {
+                run.owned.deepseekSearchKeyEnv = null;
+                return;
+            }
+            if (current !== deepseek.apiKeyEnv) {
+                await host.ports.updateNamespace(run.settings, WEB_SEARCH_DEEPSEEK_NAMESPACE, { [WEB_SEARCH_API_KEY_ENV_KEY]: deepseek.apiKeyEnv });
+            }
+            run.owned.deepseekSearchKeyEnv = deepseek.apiKeyEnv;
+            return;
+        }
+        if (previous === null)
+            return;
+        if (current !== undefined && current !== previous) {
+            run.owned.deepseekSearchKeyEnv = null;
+            return;
+        }
+        if (current !== undefined) {
+            await clearWebSearchKeyEnv(host, run.settings);
+        }
+        run.owned.deepseekSearchKeyEnv = null;
+    }
+    catch {
+        host.warn('DeepSeek 网页搜索密钥引用同步失败，搜索按当前本地配置继续');
+    }
+}
+export async function reclaimWebSearchKeyEnv(host, run) {
+    const owned = run.owned.deepseekSearchKeyEnv;
+    if (owned === null)
+        return;
+    try {
+        if (webSearchKeyEnvOf(run.settings) === owned)
+            await clearWebSearchKeyEnv(host, run.settings);
+    }
+    catch {
+        host.warn('DeepSeek 网页搜索密钥引用回收失败');
+    }
+    run.owned.deepseekSearchKeyEnv = null;
+}
+async function clearWebSearchKeyEnv(host, settings) {
+    await host.ports.clearKeys(settings, WEB_SEARCH_DEEPSEEK_NAMESPACE, [WEB_SEARCH_API_KEY_ENV_KEY]);
+}
+function webSearchKeyEnvOf(settings) {
+    const value = sectionValue(settings, WEB_SEARCH_DEEPSEEK_NAMESPACE).apiKeyEnv;
+    return typeof value === 'string' && value !== '' ? value : undefined;
+}

package/lib/domains/redmine/domain.js

@@ -0,0 +1,139 @@
+/** MCP 服务的命名空间（工具名 = `mcp__redmine__<tool>`）。 */
+export const REDMINE_SERVER_NAME = 'redmine';
+/** 单次工具调用上限：Redmine 是普通 REST 调用，附件下载也在同一档。 */
+const TOOL_CALL_TIMEOUT_MS = 60_000;
+/** boot 事实 → 挂载配置；密钥只进子进程 env，不落盘、不进日志。 */
+export function redmineMcpConfig(baseUrl, apiKey, faces) {
+    return {
+        transport: 'stdio',
+        serverName: REDMINE_SERVER_NAME,
+        command: faces.command(),
+        args: [],
+        env: {
+            REDMINE_URL: baseUrl,
+            REDMINE_API_KEY: apiKey,
+            // 只读靠上游开关关掉写工具（本插件不另设工具白名单）。
+            REDMINE_MCP_READ_ONLY: 'true',
+        },
+        cwd: faces.cwd(),
+        toolCallTimeoutMs: TOOL_CALL_TIMEOUT_MS,
+        failOnStartupError: false,
+    };
+}
+export class RedmineDomain {
+    host;
+    faces;
+    id = 'redmine';
+    mounted = null;
+    degraded = false;
+    pending = false;
+    constructor(host, faces) {
+        this.host = host;
+        this.faces = faces;
+    }
+    /**
+     * boot 事实落地：
+     * - 块缺失 / null（读取失败）→ 只 warn，保持现状（不动已挂的服务）；
+     * - 两项齐备 → 配置没变就不重挂，变了先卸再挂；
+     * - 任一项 null（权威未配置）→ 卸载。
+     */
+    async applyBoot(run) {
+        const fact = run.boot.runtimeRedmine;
+        if (fact === null || fact === undefined) {
+            this.host.warn('Redmine 配置读取失败（runtimeRedmine），保持现状不改动已挂服务');
+            this.degraded = true;
+            this.host.patchState({ redmine: null });
+            return;
+        }
+        const current = normalize(fact);
+        this.host.patchState({ redmine: current });
+        if (current.baseUrl === null || current.apiKey === null) {
+            await this.unmount();
+            this.degraded = false;
+            return;
+        }
+        const config = redmineMcpConfig(current.baseUrl, current.apiKey, this.faces);
+        if (this.mounted !== null && sameConfig(this.mounted.config, config)) {
+            this.degraded = false;
+            return;
+        }
+        await this.unmount();
+        try {
+            const server = await this.faces.mount(config);
+            this.mounted = { config, server };
+            this.degraded = false;
+            this.pending = !(await server.ready);
+            if (this.pending)
+                this.host.warn('Redmine MCP 服务尚未就绪（工具服务缺席或连接慢），就绪后工具自动出现');
+        }
+        catch (error) {
+            this.mounted = null;
+            this.degraded = true;
+            this.pending = false;
+            this.host.warn(`Redmine MCP 服务挂载失败（${error instanceof Error ? error.message : String(error)}），本次不提供 Redmine 工具`);
+        }
+    }
+    /** 登出 / 服务端整体撤下：Redmine 工具随身份一起收走。 */
+    async revert(_run) {
+        await this.unmount();
+        this.pending = false;
+        this.host.patchState({ redmine: null });
+    }
+    async unmount() {
+        const current = this.mounted;
+        this.mounted = null;
+        if (current === null)
+            return;
+        try {
+            await current.server.dispose();
+        }
+        catch (error) {
+            this.host.warn(`Redmine MCP 服务卸载失败（${error instanceof Error ? error.message : String(error)}）`);
+        }
+    }
+    statusFields(state) {
+        return { redmine: renderStatus(state) };
+    }
+    summary(state) {
+        return state.redmine === null ? null : renderStatus(state);
+    }
+    health() {
+        const state = this.host.state();
+        // 未连接（本机没凭据）不是降级：本轮根本没有服务端事实可读。
+        if (state.status === 'local')
+            return { state: 'ok', note: '未连接' };
+        if (state.redmine === null || this.degraded)
+            return { state: 'degraded', note: 'Redmine 配置读取 / 挂载失败，本次不提供工具' };
+        if (state.redmine.baseUrl === null || state.redmine.apiKey === null)
+            return { state: 'ok', note: '未配置' };
+        if (this.pending)
+            return { state: 'degraded', note: 'MCP 服务尚未就绪，工具稍后出现' };
+        return { state: 'ok', note: `${REDMINE_SERVER_NAME} 已挂载` };
+    }
+}
+/** 空串与 null 同义（服务端只发 null，这里是防御）：两项齐备才算可用。 */
+function normalize(fact) {
+    return {
+        baseUrl: fact.baseUrl === null || fact.baseUrl === '' ? null : fact.baseUrl,
+        apiKey: fact.apiKey === null || fact.apiKey === '' ? null : fact.apiKey,
+    };
+}
+function sameConfig(a, b) {
+    return a.command === b.command &&
+        a.cwd === b.cwd &&
+        a.env.REDMINE_URL === b.env.REDMINE_URL &&
+        a.env.REDMINE_API_KEY === b.env.REDMINE_API_KEY;
+}
+/** 状态行文案：未连接 / 读取失败 / 未配置 / 已启用 + 地址。 */
+function renderStatus(state) {
+    if (state.status === 'local')
+        return '';
+    const fact = state.redmine;
+    if (fact === null)
+        return '读取失败';
+    if (fact.baseUrl === null)
+        return '未配置（缺 Redmine 地址）';
+    if (fact.apiKey === null)
+        return '未配置（本人未填密钥）';
+    return `已启用 · ${fact.baseUrl}`;
+}

package/lib/domains/redmine/index.js

@@ -0,0 +1,57 @@
+import { RedmineDomain, } from './domain.js';
+/** 等领域服务的等待上限：超时只记降级（光纤留着，工具服务晚到时官方那边自己接上）。 */
+const MOUNT_WAIT_MS = 2_000;
+/** 起进程的命令：镜像里在 PATH 上；npm 消费者可用 `SEMI2_REDMINE_MCP_BIN` 指到别处（同 CodeGraph 口径）。 */
+export function redmineMcpCommand(env) {
+    const override = env.SEMI2_REDMINE_MCP_BIN?.trim();
+    return override === undefined || override === '' ? 'redmine-mcp-server' : override;
+}
+/** 子进程工作目录 = 本面工作目录（同 CodeGraph 挂载行）。 */
+export function redmineMcpCwd(env) {
+    const workspace = env.SEMI2_WORKSTATION_CWD?.trim();
+    return workspace === undefined || workspace === '' ? process.cwd() : workspace;
+}
+/** 到时限还没就绪即 false；激活失败也算 false（调用方只记一条 warn）。 */
+async function within(promise, ms) {
+    let timer;
+    try {
+        return await Promise.race([
+            Promise.resolve(promise).then(() => true, () => false),
+            new Promise((resolve) => {
+                timer = setTimeout(() => {
+                    resolve(false);
+                }, ms);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+/** 运行面能力：动态 import 官方包 + 在本领域的 ctx 上挂一根光纤（dispose 由领域持有）。 */
+export function createRedmineFaces(ctx) {
+    return {
+        mount: async (config) => {
+            const module = (await import('@deepseek-ai/dsh-mcp-client'));
+            const fiber = ctx.plugin(module, config);
+            return {
+                ready: within(fiber, MOUNT_WAIT_MS),
+                dispose: async () => {
+                    await fiber.dispose();
+                },
+            };
+        },
+        command: () => redmineMcpCommand(process.env),
+        cwd: () => redmineMcpCwd(process.env),
+    };
+}
+export const redmineDomain = {
+    id: 'redmine',
+    operations: ['RuntimeBoot'],
+    statusKeys: ['redmine'],
+    apply(ctx, config) {
+        const domain = new RedmineDomain(config.host, createRedmineFaces(ctx));
+        config.host.attach(domain);
+    },
+};

package/lib/domains/skills/candidates.js

@@ -16,11 +16,12 @@ export function candidateOf(skill, warn) {
         description: skill.description,
         // exactOptionalPropertyTypes：可选字段只能用条件展开，不能赋 undefined。
         ...(skill.whenToUse ? { whenToUse: skill.whenToUse } : {}),
+        ...(skill.metadata === null ? {} : { metadata: skill.metadata }),
         rank: HUB_SKILL_RANK,
         locator: skill.id,
         source: 'custom',
         provider: 'semi2-hub',
-        invocation: { modelInvocable: true, userInvocable: true },
+        invocation: { ...skill.invocation },
     };
 }
 export function definitionOf(skill) {
@@ -28,9 +29,10 @@ export function definitionOf(skill) {
         name: skill.name,
         description: skill.description,
         ...(skill.whenToUse ? { whenToUse: skill.whenToUse } : {}),
+        ...(skill.metadata === null ? {} : { metadata: skill.metadata }),
         content: skill.content,
         source: 'custom',
         provider: 'semi2-hub',
-        invocation: { modelInvocable: true, userInvocable: true },
+        invocation: { ...skill.invocation },
     };
 }

package/lib/domains/skills/domain.js

@@ -30,14 +30,14 @@ export class SkillsDomain {
         return this.current;
     }
     /**
-     * 控制台技能目录：`runtimeSkills` 为 null/undefined 都算「没拿到权威目录」——null 只降级该块，
+     * 控制台技能目录：`runtimeSkillCatalog` 为 null/undefined 都算「没拿到权威目录」——null 只降级该块，
      * null ≠ 空数组（provider 据此报 complete:false，dsh 才不把抖动缓存成空目录）。
      */
     applyBoot(run) {
         const boot = run.boot;
-        const skills = boot.runtimeSkills;
+        const skills = boot.runtimeSkillCatalog;
         if (skills === null || skills === undefined) {
-            this.host.warn('技能目录读取失败（runtimeSkills），本次不提供控制台技能');
+            this.host.warn('技能目录读取失败（runtimeSkillCatalog），本次不提供控制台技能');
             this.degraded = true;
             this.current = null;
             return Promise.resolve();
@@ -49,6 +49,8 @@ export class SkillsDomain {
             name: skill.name,
             description: skill.description,
             whenToUse: skill.whenToUse,
+            invocation: { ...skill.invocation },
+            metadata: skill.metadata === null ? null : { ...skill.metadata },
             content: skill.content,
             version: skill.version,
             files: fileFactsOf(skill),

package/lib/domains/workspace/domain.js

@@ -1,7 +1,7 @@
 import { persistedWorkspaces, trackedWorkspaces, WorkspaceBook, } from '../../hub/workspace-book.js';
 import { renderWorkspaces } from '../../hub/status.js';
 import { codeOf } from '../../hub/errors.js';
-import { WORKSPACES_NAMESPACE } from '../../service/namespaces.js';
+import { SEMI2_SETTINGS_ENTRY } from '../../service/namespaces.js';
 import { projectForCwd, syncAll, syncBySlug, syncOne, } from './resolve.js';
 export class WorkspaceDomain {
     host;
@@ -125,7 +125,8 @@ export class WorkspaceDomain {
         if (settings === undefined)
             return;
         try {
-            await this.host.ports.replaceNamespace(settings, WORKSPACES_NAMESPACE, {
+            // 合并写入：同一段里还有状态与归属表，整体替换会把它们一起重置。
+            await this.host.ports.updateNamespace(settings, SEMI2_SETTINGS_ENTRY, {
                 entries: persistedWorkspaces(this.tracked()),
             });
         }

package/lib/hub/facts.js

@@ -10,6 +10,7 @@ export function initialState(connect, consoleUrl, workspaces = []) {
         // null = 没拿到权威技能目录（≠ 空目录）：provider 据此不得谎报权威空。
         skills: null,
         selfPortrait: '',
+        redmine: null,
         projects: [],
         workspaces,
     };

package/lib/index.js

@@ -1,13 +1,18 @@
 import z from '@deepseek-ai/schemastery';
 import { installConfiguration } from './service/config-service.js';
+import { STATE_CONFIG_FIELDS } from './service/settings-sections.js';
 import { installWebSurface } from './web/index.js';
-export { SEMI2_RUNTIME_SERVICE, SEMI2_SECTION_ORDERS, runtimeFromCnbEnv, runtimeFromContainerEnv, semi2SectionOrder, } from './contract.js';
+export { SEMI2_RUNTIME_SERVICE, SEMI2_SECTION_ORDERS, SEMI2_SETTINGS_ENTRY, runtimeFromCnbEnv, runtimeFromContainerEnv, semi2SectionOrder, } from './contract.js';
 // 事件签名声明（semi2/config-updated / semi2/workspaces-updated）唯一出处。
 import './events.js';
 export const name = 'semi2-dsh';
 /**
  * 可调参数：默认值 = 各模块曾经的常量；bundle patch 行不写 config，消费方 overlay 才覆盖。
  * 「config 明确值 → 环境变量 → 内置常量」的取值顺序在 apply 里一次归一。
+ *
+ * 状态 / 健康 / 工作区 tab / 归属表 / 工作区映射（`STATE_CONFIG_FIELDS`）同在这一段里，但全部声明为
+ * volatile（可实时写、不重挂载）：dsh 的 `describe()` 只认有 volatile 字段的条目，本插件的设置段
+ * 靠它才存在。这些字段一律经 `describe()` 读写，不在 `apply` 里当普通值取（volatile 字段在 config 上是引用）。
  */
 export const Config = z.object({
     /** 等运行面契约（`semi2Runtime`）出现的上限：超时按宿主直跑处理。 */
@@ -16,15 +21,16 @@ export const Config = z.object({
     domainAttachTimeoutMs: z.number().default(2_000),
     /** 等 settings 服务的上限：本面无该服务时不阻塞启动。 */
     settingsTimeoutMs: z.number().default(5_000),
-    /** 等命名空间注册完成再写的上限。 */
+    /** 等设置段可读可写（条目 ACTIVE 且声明了 volatile 字段）的上限。 */
     namespaceWaitMs: z.number().default(2_000),
     /** 凭据存储首次读盘的重试次数与间隔。 */
     credentialRetryTries: z.number().default(10),
     credentialRetryIntervalMs: z.number().default(150),
     /** webServer 在而校验面迟迟不出现时，多久补一条诊断日志。 */
     webFenceTimeoutMs: z.number().default(5_000),
-    /** 登录 / 登出 / 健康路由的请求体上限（字节）。 */
+    /** 登录 / 登出 / 同步 / 健康路由的请求体上限（字节）。 */
     webRouteBodyLimitBytes: z.number().default(8_192),
+    ...STATE_CONFIG_FIELDS,
 });
 /** CodeGraph 开关：挂载行的 `disabled` 同口径（bundle patch），插件只把它反映到健康行。 */
 function codegraphDisabled(env) {
@@ -58,14 +64,6 @@ export function apply(ctx, config) {
     ctx.provide('semi2Health', configuration.health);
     // 运行面（NPC 面）回报生命周期与交付事实的出口；上报失败只 warn。
     ctx.provide('semi2Audit', configuration.audit);
-    // 优雅卸载 = 本面会话结束：进程被强杀（SIGKILL / 容器停止）没有结束行，属已知边界。
-    ctx.effect(() => () => {
-        void configuration.audit.report({
-            action: 'SESSION_END',
-            outcome: 'SUCCESS',
-            detail: { platform: configuration.config.platform, reason: 'dispose' },
-        });
-    });
     // 索引由使用方建立、工具由官方 MCP 服务提供：插件侧没有可失败的后台动作，只标注开关状态。
     configuration.registerHealth({
         key: 'healthCodegraph',
@@ -76,6 +74,7 @@ export function apply(ctx, config) {
     installWebSurface(ctx, {
         login: input => configuration.session.login(input),
         logout: () => configuration.session.logout(),
+        sync: scope => configuration.session.sync(scope),
         health: () => configuration.health.snapshot(),
     }, (contributor) => {
         configuration.registerHealth(contributor);

package/lib/service/audit.js

@@ -1,19 +1,33 @@
-/** 生命周期事件：动作名与结果名都用 hub SDL 的枚举名，两侧不各维护一张映射表。 */
-export async function reportEvent(engine, event) {
+/**
+ * 上报一条运行面事件并回结果：本面标识（`face`）与运行面契约里的任务引用在这里补齐，
+ * 调用方（会话订阅 / 适配器）不必各自知道这两个事实从哪来。
+ */
+export async function reportEventResult(engine, event) {
+    if (engine.connection() === null)
+        return { ok: false, code: 'MISSING_ACCESS_TOKEN' };
+    // 任务引用来自运行面契约（NPC 适配器解析触发后填），本插件不自己解析触发事实。
+    const taskRef = engine.contract()?.taskRef;
     try {
-        if (engine.connection() === null)
-            return;
         const outcome = await engine.api.reportEvent({
             ...event,
+            ...(taskRef === undefined || taskRef === '' ? {} : { runRef: taskRef }),
             detail: { face: faceOf(engine), ...(event.detail ?? {}) },
         });
-        if (outcome.data === null)
-            engine.warn(`运行面事件上报失败（${event.action}）：${outcome.errorCode ?? '未知错误'}`);
+        return { ok: outcome.data !== null, code: outcome.errorCode };
     }
     catch (error) {
-        engine.warn(`运行面事件上报失败（${event.action}）：${error instanceof Error ? error.message : String(error)}`);
+        return {
+            ok: false,
+            code: error instanceof Error ? error.message : String(error),
+        };
     }
 }
+/** 生命周期事件：动作名与结果名都用 hub SDL 的枚举名，两侧不各维护一张映射表。 */
+export async function reportEvent(engine, event) {
+    const result = await reportEventResult(engine, event);
+    if (!result.ok)
+        engine.warn(`运行面事件上报失败（${event.action}）：${result.code ?? '未知错误'}`);
+}
 /** 本面标识：契约里有就用它；宿主直跑没有契约，记 host。 */
 export function faceOf(engine) {
     const declared = engine.contract()?.face;

package/lib/service/config-service.js

@@ -1,7 +1,8 @@
 import { createSemi2Api } from '../api/index.js';
 import { createPorts } from './ports.js';
 import { Orchestrator } from './orchestrator.js';
-import { faceOf } from './audit.js';
+import { reportEventResult } from './audit.js';
+import { installSessionReporting } from './sessions.js';
 import * as lifecycle from './lifecycle.js';
 /**
  * 装配三个能力面并开始后台领取：领域挂载与首次取数都在后台——不阻塞插件树 settle，
@@ -23,9 +24,13 @@ export function installConfiguration(ctx, options = {}) {
         createSemi2Api({
             readConnection: () => engineRef.current?.connection() ?? null,
             environment: { ...process.env },
-            readFace: () => engineRef.current?.contract()?.face,
+            // 契约缺席即宿主直跑：本面标识回落 `host`，别让会话落成「未标注」。
+            readFace: () => engineRef.current?.contract()?.face ??
+                (engineRef.current?.platform === 'host' ? 'host' : undefined),
         }), ports, { ...process.env }, options);
     engineRef.current = orchestrator;
+    // 客户端会话日志的事实来源：旁听 dsh 的会话创建 / 销毁（服务缺席时自动跳过）。
+    installSessionReporting(orchestrator);
     void orchestrator
         .mountDomains()
         .then(() => lifecycle.start(orchestrator))
@@ -37,29 +42,11 @@ export function installConfiguration(ctx, options = {}) {
         session: {
             login: input => lifecycle.login(orchestrator, input),
             logout: () => lifecycle.logout(orchestrator),
+            sync: scope => lifecycle.syncByScope(orchestrator, scope),
         },
         health: { snapshot: () => orchestrator.healthSnapshot() },
         audit: {
-            report: async (event) => {
-                if (orchestrator.connection() === null)
-                    return { ok: false, code: 'MISSING_ACCESS_TOKEN' };
-                try {
-                    const outcome = await orchestrator.api.reportEvent({
-                        ...event,
-                        detail: {
-                            face: faceOf(orchestrator),
-                            ...(event.detail ?? {}),
-                        },
-                    });
-                    return { ok: outcome.data !== null, code: outcome.errorCode };
-                }
-                catch (error) {
-                    return {
-                        ok: false,
-                        code: error instanceof Error ? error.message : String(error),
-                    };
-                }
-            },
+            report: event => reportEventResult(orchestrator, event),
         },
         registerHealth: (contributor) => {
             orchestrator.registerHealthContributor(contributor);