@zmzai/agent-framework 0.4.0 → 0.5.0

package/dist/core/runtime/runner.js

@@ -1,4 +1,5 @@
 import { Agent } from "@earendil-works/pi-agent-core";
+import { validateAttachments, attachmentContent } from "./attachments.js";
 import { leaseDurationMs } from "../../adapters/index.js";
 import { notifyEventLogListeners } from "../events/bus.js";
 import { PermissionEngine, RejectedError } from "../permission/engine.js";
@@ -12,6 +13,7 @@ import { isExternalToolDef } from "../tools/def.js";
 import { fireRunStart, firstToolBlock, fireAfterToolCall, fireRunEnd } from "./lifecycle.js";
 import { extractRunTranscript, RETRY_PLACEHOLDER_TEXT } from "./run-transcript.js";
 import { noopSandboxExecutor } from "../../adapters/index.js";
+import { randomUUID } from "node:crypto";
 /** 事件的 sessionId 提取：能自带的自带（message/part/session），其余
  *  （message.part.delta 等）用发起 run 的会话 id 兜底。 */
 function sessionIdOf(event, fallbackSessionId) {
@@ -89,6 +91,49 @@ export class SessionRunner {
     constructor(deps) {
         this.deps = deps;
     }
+    draining = new Map();
+    stopRequested = new Set();
+    drain(sessionId) {
+        if (this.draining.has(sessionId))
+            return;
+        const work = (async () => {
+            while (true) {
+                const job = await this.deps.store.workflow.claimPrompt(sessionId, `node:${process.pid}`);
+                if (!job)
+                    return;
+                let outcome = "recovery_required";
+                try {
+                    if (this.stopRequested.has(sessionId)) {
+                        outcome = "cancelled";
+                    }
+                    else {
+                        const session = await this.deps.store.getSession(sessionId);
+                        if (!session) {
+                            outcome = "failed";
+                        }
+                        else {
+                            outcome = await this.runLoop(session, job.input, job.receipt.userMessageId);
+                        }
+                    }
+                }
+                catch {
+                    // Setup or settlement may have failed after a tool ran. Do not replay.
+                }
+                await this.deps.store.workflow.finishPrompt(sessionId, job.receipt.runId, job.revision, outcome);
+                if (outcome !== "completed")
+                    return;
+            }
+        })();
+        this.draining.set(sessionId, work);
+        void work.catch(() => undefined).finally(async () => {
+            this.draining.delete(sessionId);
+            if (this.stopRequested.has(sessionId))
+                return;
+            const queued = await this.deps.store.workflow.workflowRuns(sessionId).catch(() => []);
+            if (queued.some(run => run.status === "queued") && !queued.some(run => run.status === "running" || run.status === "recovery_required"))
+                this.drain(sessionId);
+        });
+    }
     #hooks = [];
     /** 供 runLoop 取归一化钩子数组（lazy：constructor 后仍可由 deps 引用共享）。 */
     get hooks() {
@@ -100,6 +145,12 @@ export class SessionRunner {
      *  单例，两个会话并发时实例字段会互相覆盖，导致 message.part.delta 等
      *  无自带 sessionId 的事件落到错误的会话事件流里（串台）。 */
     async persist(event, fallbackSessionId) {
+        const sessionId = sessionIdOf(event, fallbackSessionId);
+        if (this.deps.store.persistEvent) {
+            const persisted = await this.deps.store.persistEvent({ sessionId, ...event });
+            notifyEventLogListeners(persisted);
+            return;
+        }
         if (event.type === "message.updated") {
             const message = event.data.message;
             const exists = await this.deps.store.getMessages(message.sessionId).then((entries) => entries.some((entry) => entry.info.id === message.id));
@@ -114,11 +165,13 @@ export class SessionRunner {
         else if (event.type === "session.updated") {
             await this.deps.store.updateSession(event.data.session.id, event.data.session);
         }
-        const persisted = await this.deps.eventLog.append({ sessionId: sessionIdOf(event, fallbackSessionId), ...event });
+        const persisted = await this.deps.eventLog.append({ sessionId, ...event });
         notifyEventLogListeners(persisted);
     }
     async publish(event, sessionId) {
-        const persisted = await this.deps.eventLog.append({ sessionId, ...event });
+        const persisted = this.deps.store.persistEvent
+            ? await this.deps.store.persistEvent({ sessionId, ...event })
+            : await this.deps.eventLog.append({ sessionId, ...event });
         notifyEventLogListeners(persisted);
     }
     async stampLease(sessionId) {
@@ -132,11 +185,37 @@ export class SessionRunner {
         await this.deps.leaseStore.clear(sessionId).catch(() => undefined);
     }
     async prompt(sessionId, input) {
+        input = { ...input, attachments: validateAttachments(input.attachments) };
         const session = await this.deps.store.getSession(sessionId);
         if (!session)
             throw new Error("SESSION_NOT_FOUND");
+        if (this.deps.store.workflow) {
+            input = { ...input, requestId: input.requestId ?? randomUUID(), model: input.model ?? session.model };
+            const projector = new PartProjector({ sessionId, agent: input.agent ?? session.agent, model: input.model });
+            const parts = [];
+            const message = projector.onUserPrompt(event => {
+                if (event.type === "message.part.updated")
+                    parts.push(event.data.part);
+            }, input.text, input.images, input.skill, input.references, input.attachments);
+            const accepted = await this.deps.store.workflow.acceptPrompt(sessionId, input, { message, parts });
+            for (const event of accepted.events)
+                notifyEventLogListeners(event);
+            if (accepted.events.length)
+                this.drain(sessionId);
+            return accepted.receipt;
+        }
         if (activeRuns.has(sessionId)) {
-            await this.deps.store.enqueuePrompt(sessionId, { text: input.text, ...(input.agent ? { agent: input.agent } : {}), ...(input.effort ? { effort: input.effort } : {}), enqueuedAt: new Date().toISOString() });
+            await this.deps.store.enqueuePrompt(sessionId, {
+                text: input.text,
+                attachments: input.attachments,
+                images: input.images,
+                model: input.model,
+                ...(input.agent ? { agent: input.agent } : {}),
+                ...(input.effort ? { effort: input.effort } : {}),
+                ...(input.skill ? { skill: input.skill } : {}),
+                ...(input.references?.length ? { references: [...input.references] } : {}),
+                enqueuedAt: new Date().toISOString(),
+            });
             return { queued: true };
         }
         void this.runLoop(session, input);
@@ -163,16 +242,19 @@ export class SessionRunner {
         return removedFromEngine || removedFromStore;
     }
     async abort(sessionId) {
-        const active = activeRuns.get(sessionId);
+        this.stopRequested.add(sessionId);
         await this.deps.store.clearQueuedPrompts(sessionId);
-        if (!active)
-            return;
+        const active = activeRuns.get(sessionId);
         // PI's abort signal does not cancel a PermissionEngine.ask() promise.
         // Rejecting pending approvals first releases beforeToolCall so the run can
         // publish its terminal state and a continuation cannot overlap it.
-        active.engine.dispose("任务已停止，未处理的授权请求已取消");
-        active.abort();
-        await active.done;
+        if (active) {
+            active.engine.dispose("任务已停止，未处理的授权请求已取消");
+            active.abort();
+            await active.done;
+        }
+        await this.draining.get(sessionId);
+        this.stopRequested.delete(sessionId);
     }
     /** 手动触发一次上下文压缩（UI「压缩当前会话」）：无条件对当前历史跑一次
      *  摘要折叠，摘要通过 buildCompaction 的 onCompacted 落为 compaction part
@@ -187,7 +269,11 @@ export class SessionRunner {
         const transform = await this.buildCompaction(session, (event) => this.publish(event, session.id), true);
         if (!transform)
             return { ok: false, reason: "compaction-disabled" };
-        const messages = await this.rebuildMessages(sessionId);
+        const workflowRuns = this.deps.store.workflow ? await this.deps.store.workflow.workflowRuns(sessionId) : [];
+        const excludedUserIds = this.deps.store.workflow
+            ? new Set(workflowRuns.filter((run) => run.status !== "completed" && run.status !== "failed").map((run) => run.receipt.userMessageId))
+            : undefined;
+        const messages = await this.rebuildMessages(sessionId, excludedUserIds);
         if (messages.length <= 1)
             return { ok: false, reason: "nothing-to-compact" };
         await transform(messages);
@@ -269,12 +355,23 @@ export class SessionRunner {
             return null;
         }
     }
-    async runLoop(session, input) {
+    async runLoop(session, input, acceptedUserId) {
         const registry = await this.registryFor(session);
         const resolved = await this.resolvedAgentFor(session);
         const agentName = resolved ? resolved.agent.name : input.agent ?? session.agent;
         const agentInfo = resolved?.agent ?? registry.get(agentName) ?? registry.get("default");
         const model = input.model ?? agentInfo?.model ?? session.model;
+        // 回写当轮实际模型：session.model 是「会话当前模型」的持久来源，但
+        // prompt 传入的 model / agent 声明的 model 此前只用于当轮、从不落库，
+        // 于是所有读 session.model 的旁路（压缩阈值 contextWindowFor、总结
+        // 陈词 summarizeRun、子代理继承、宿主侧标题生成）拿到的都是建会话时
+        // 的旧模型甚至 env 兜底值。回写后这些旁路自动跟随当轮模型，无需各自
+        // 传参。必须在 buildCompaction 之前完成，否则压缩阈值仍按旧模型算。
+        if (model.providerId !== session.model?.providerId || model.modelId !== session.model?.modelId) {
+            await this.deps.store.updateSession(session.id, { model }).catch(() => undefined);
+            // 同步内存引用：本轮后续（buildCompaction/闭包捕获）都用新模型
+            session = { ...session, model };
+        }
         const agentRulesets = resolved ? [registry.rulesetsFor("default")[0], resolved.agent.permission] : registry.rulesetsFor(agentInfo?.name ?? "default");
         const engine = new PermissionEngine(session.id, agentRulesets, session.permission, {
             onAsked: async (request) => {
@@ -299,6 +396,15 @@ export class SessionRunner {
             await this.persist(event, session.id);
         });
         const projector = new PartProjector({ sessionId: session.id, agent: agentInfo?.name ?? "default", model });
+        if (acceptedUserId)
+            projector.restoreUserMessage(acceptedUserId);
+        let mandatorySkillContext = "";
+        if (input.skill) {
+            if (!this.deps.resolveMandatorySkill)
+                throw new Error("该运行环境不支持 Skill 加载");
+            const loaded = await this.deps.resolveMandatorySkill(session, input.skill);
+            mandatorySkillContext = loaded.context;
+        }
         // Exclude task from contexts that can't nest; include for primary runs.
         const baseTools = [...(this.deps.tools ?? builtinTools), ...(this.deps.localTools ?? []), ...(resolved?.tools ?? [])];
         const toolList = session.parentId ? baseTools.filter((def) => def.id !== "task") : baseTools;
@@ -309,8 +415,7 @@ export class SessionRunner {
         const rawWorkspace = this.deps.workspaceFor(session);
         const workspace = session.writePaths?.length ? confineWorkspaceFiles(rawWorkspace, session.writePaths) : rawWorkspace;
         const emitAsync = async (event) => {
-            const persisted = await this.deps.eventLog.append({ sessionId: session.id, ...event });
-            notifyEventLogListeners(persisted);
+            await this.publish(event, session.id);
         };
         const toolContext = (this.deps.buildToolContext ?? defaultToolContext)({ session, engine, workspace, sandbox, emit: emitAsync });
         // Subagent spawning is only available to primary (non-child) sessions, and
@@ -323,7 +428,11 @@ export class SessionRunner {
         const compactionTransform = await this.buildCompaction(session, emit);
         // 记忆召回（spec §记忆）：单点注入 runLoop，天然覆盖正常 prompt/排队出
         // 队/automation/子代理触发四条路径。只进内存不落 store；抛错静默降级。
-        const history = await this.rebuildMessages(session.id);
+        const workflowRuns = this.deps.store.workflow ? await this.deps.store.workflow.workflowRuns(session.id) : [];
+        const excludedUserIds = this.deps.store.workflow
+            ? new Set(workflowRuns.filter((run) => run.status !== "completed" && run.status !== "failed").map((run) => run.receipt.userMessageId))
+            : undefined;
+        const history = await this.rebuildMessages(session.id, excludedUserIds);
         if (this.deps.memoryContextFor) {
             try {
                 const section = await this.deps.memoryContextFor(session, input.text);
@@ -339,7 +448,7 @@ export class SessionRunner {
         const baseline = history.length;
         const agent = new Agent({
             initialState: {
-                systemPrompt: agentInfo?.prompt ?? "",
+                systemPrompt: [agentInfo?.prompt ?? "", mandatorySkillContext, input.references?.length ? `<attached-resources>\nThe user attached these workspace paths. Read the relevant ones before acting:\n${input.references.join("\n")}\n</attached-resources>` : ""].filter(Boolean).join("\n\n"),
                 model: this.deps.modelFor(model),
                 // 推理力度（P1-8 复活）：relay 现已按模型白名单接受 reasoning_effort；
                 // 仅当调用方显式选择且非 off 时下发（默认不设 = 完全不带该字段）。
@@ -360,6 +469,8 @@ export class SessionRunner {
         let resolveDone;
         const done = new Promise((resolve) => { resolveDone = resolve; });
         activeRuns.set(session.id, { agent, engine, settled, abort, done });
+        if (this.stopRequested.has(session.id))
+            abort();
         await this.stampLease(session.id);
         const loopGuard = new LoopGuard();
         agent.beforeToolCall = async ({ toolCall, args }) => {
@@ -538,15 +649,18 @@ export class SessionRunner {
                 data: { toolCalls: summaryToolCalls, lastTool: summaryLastTool, elapsedMs },
             }, session.id).catch(() => undefined);
         }, CHECKPOINT_INTERVAL_MS);
-        await Promise.all(fireRunStart(this.hooks, { sessionId: session.id, agent: session.agent, text: input.text }));
-        await this.publish({ type: "session.status", data: { status: "running" } }, session.id);
         try {
-            projector.onUserPrompt(emit, input.text, input.images);
+            await Promise.all(fireRunStart(this.hooks, { sessionId: session.id, agent: session.agent, text: input.text }));
+            await this.publish({ type: "session.status", data: { status: "running" } }, session.id);
+            if (abortController.signal.aborted)
+                throw new Error("Run cancelled during setup");
+            if (!acceptedUserId)
+                projector.onUserPrompt(emit, input.text, input.images, input.skill, input.references, input.attachments);
             const piImages = input.images?.map((img) => {
                 const match = img.url.match(/^data:([^;]+);base64,(.+)$/);
                 return match ? { type: "image", data: match[2], mimeType: match[1] } : null;
             }).filter((img) => img !== null);
-            await agent.prompt(input.text, piImages?.length ? piImages : undefined);
+            await agent.prompt({ role: "user", content: [{ type: "text", text: input.text }, ...attachmentContent(input.attachments ?? []), ...(piImages ?? [])], timestamp: Date.now() });
             await settled();
             let failed = agent.state.errorMessage;
             if (unknownSideEffect) {
@@ -597,13 +711,17 @@ export class SessionRunner {
                 : aborted
                     ? { type: "session.status", data: { status: "idle" } }
                     : { type: "session.error", data: { name: "AgentRuntimeError", message: error instanceof Error ? error.message : "Agent 运行失败" } }, session.id);
+            if (!aborted && !unknownSideEffect)
+                await this.publish({ type: "session.status", data: { status: "idle" } }, session.id);
         }
         finally {
             clearInterval(streamWatchdog);
             clearInterval(checkpointTimer);
             activeRuns.delete(session.id);
             engine.dispose();
-            await this.clearLease(session.id);
+            // Workflow settlement clears its lease atomically with the terminal run state.
+            if (!acceptedUserId)
+                await this.clearLease(session.id);
             const newMessages = extractRunTranscript(agent.state.messages, baseline);
             // 任务终态小结（N5）：终态 status 已发布后补一条 session.summary，
             // 让「任务完成」有明确收尾（AI 一句总结 + 结构化统计）。await 保证
@@ -619,15 +737,26 @@ export class SessionRunner {
             void Promise.all(fireRunEnd(this.hooks, { sessionId: session.id, agent: session.agent, ok: !runErrored, aborted: abortController.signal.aborted, workspaceId: session.workspaceId, newMessages }));
             resolveDone();
         }
-        if (unknownSideEffect)
-            return;
+        const outcome = unknownSideEffect ? "recovery_required" : abortController.signal.aborted ? "cancelled" : runErrored ? "failed" : "completed";
+        if (acceptedUserId || unknownSideEffect)
+            return outcome;
         // FIFO queued prompts (spec §13.3): settle fully, then take the next one.
         const next = await this.deps.store.dequeuePrompt(session.id);
         if (next) {
             const latest = await this.deps.store.getSession(session.id);
             if (latest)
-                await this.runLoop(latest, { text: next.text, ...(next.agent ? { agent: next.agent } : {}), ...(next.effort ? { effort: next.effort } : {}) });
+                await this.runLoop(latest, {
+                    text: next.text,
+                    attachments: next.attachments,
+                    images: next.images,
+                    model: next.model,
+                    ...(next.agent ? { agent: next.agent } : {}),
+                    ...(next.effort ? { effort: next.effort } : {}),
+                    ...(next.skill ? { skill: next.skill } : {}),
+                    ...(next.references?.length ? { references: [...next.references] } : {}),
+                });
         }
+        return outcome;
     }
     /** Spawns a subagent child session (spec §6.4): depth-capped, permission
      *  stamped from parent session + subagent preset, runs a nested PI loop to
@@ -724,36 +853,52 @@ export class SessionRunner {
         // 终态先落 session 记录（列表三态用，N5）——即使 summaryModel 缺失或生成
         // 失败，lastOutcome 也要写回，保证列表能区分完成/中断/失败。
         await this.deps.store.updateSession(session.id, { lastOutcome: input.kind }).catch(() => undefined);
-        const summaryModel = this.deps.compaction?.summaryModel ?? null;
-        if (!summaryModel)
-            return;
+        const durationMs = Date.now() - input.startedAt;
+        const meta = { filesEdited: input.stats.editedFiles.length, toolCalls: input.stats.toolCalls, durationMs };
+        // 兜底文案：summary 生成失败 / 无模型 / 超时 / 空文本时，仍然发一条带
+        // meta 的 session.summary，保证前端「任务完成卡」三态必现，而非悄无声息结束。
+        const fallbackText = input.kind === "completed"
+            ? `本轮任务已完成，共 ${meta.toolCalls} 次工具调用${meta.filesEdited > 0 ? `，改动 ${meta.filesEdited} 个文件` : ""}。`
+            : input.kind === "aborted"
+                ? `本轮任务已中断，已完成 ${meta.toolCalls} 次工具调用${meta.filesEdited > 0 ? `，改动 ${meta.filesEdited} 个文件` : ""}。`
+                : `本轮任务执行出错，已完成 ${meta.toolCalls} 次工具调用${meta.filesEdited > 0 ? `，改动 ${meta.filesEdited} 个文件` : ""}。`;
+        // 总结模型沿用「会话实际模型」而非 compaction 专用 summaryModel，保证
+        // 总结卡文案由当前会话正在用的模型生成。仅当 compaction 启用时才做 AI
+        // 总结（否则落到兜底文案），但模型来源与会话模型解耦。modelFor 抛错
+        // （宿主 provider 不认识该 ref）时回落 compaction.summaryModel，再不行
+        // 落到下方兜底文案。
+        let summaryModel = null;
+        if (this.deps.compaction?.enabled) {
+            try {
+                summaryModel = this.deps.modelFor(session.model);
+            }
+            catch {
+                summaryModel = this.deps.compaction.summaryModel ?? null;
+            }
+        }
         // 本轮新增消息（baseline 之后），只取 user/assistant 文本作总结素材
         const messages = input.agent.state.messages.slice(input.baseline);
         const textMessages = messages.filter((m) => m.role === "user" || m.role === "assistant");
-        if (textMessages.length === 0)
-            return;
-        const durationMs = Date.now() - input.startedAt;
-        const meta = { filesEdited: input.stats.editedFiles.length, toolCalls: input.stats.toolCalls, durationMs };
-        // 总结提示词：只描述本轮做了什么，一句/几句自然语言，不续写
-        const systemPrompt = "你是任务收尾助手。根据用户本轮的任务与助手已完成的工作，写一句简短、克制的中文总结（1-2 句），" +
-            "说明「做了什么、结果如何、下一步建议」。不要客套、不要问句、不要续写任务，只输出总结正文。";
         let text = "";
-        try {
-            const { streamOneText } = await import("./compaction.js");
-            const streamFn = this.deps.streamFnFor(session);
-            // 15s 超时兜底：summary 是收尾的锦上添花，不能因为上游慢而卡住 run 收尾。
-            text = await Promise.race([
-                streamOneText(async (m, ctx) => streamFn(m, ctx), summaryModel, systemPrompt, textMessages),
-                new Promise((resolve) => setTimeout(() => resolve(""), 15_000)),
-            ]);
-        }
-        catch {
-            /* 总结生成失败静默跳过 */
+        if (summaryModel && textMessages.length > 0) {
+            // 总结提示词：只描述本轮做了什么，一句/几句自然语言，不续写
+            const systemPrompt = "你是任务收尾助手。根据用户本轮的任务与助手已完成的工作，写一句简短、克制的中文总结（1-2 句），" +
+                "说明「做了什么、结果如何、下一步建议」。不要客套、不要问句、不要续写任务，只输出总结正文。";
+            try {
+                const { streamOneText } = await import("./compaction.js");
+                const streamFn = this.deps.streamFnFor(session);
+                // 15s 超时兜底：summary 是收尾的锦上添花，不能因为上游慢而卡住 run 收尾。
+                text = await Promise.race([
+                    streamOneText(async (m, ctx) => streamFn(m, ctx), summaryModel, systemPrompt, textMessages),
+                    new Promise((resolve) => setTimeout(() => resolve(""), 15_000)),
+                ]);
+            }
+            catch {
+                /* 总结生成失败 → 落到下方兜底文案 */
+            }
         }
         const trimmed = text.trim();
-        if (!trimmed)
-            return;
-        await this.publish({ type: "session.summary", data: { text: trimmed, kind: input.kind, meta } }, session.id).catch(() => undefined);
+        await this.publish({ type: "session.summary", data: { text: trimmed || fallbackText, kind: input.kind, meta } }, session.id).catch(() => undefined);
     }
     async lastAssistantText(sessionId) {
         const entries = await this.deps.store.getMessages(sessionId);
@@ -783,16 +928,20 @@ export class SessionRunner {
         }
         return depth;
     }
-    async rebuildMessages(sessionId) {
+    async rebuildMessages(sessionId, excludedUserIds) {
         const entries = await this.deps.store.getMessages(sessionId);
         const messages = [];
         for (const { info, parts } of entries) {
             if (info.role === "user") {
+                if (excludedUserIds?.has(info.id))
+                    continue;
                 const text = parts
                     .filter((part) => part.type === "text")
                     .map((part) => part.text)
                     .join("\n");
-                messages.push({ role: "user", content: text || "（空消息）", timestamp: Date.parse(info.time.created) || Date.now() });
+                const files = parts.filter((p) => p.type === "file" && p.url.startsWith("data:"));
+                const attachments = files.map((p) => ({ name: p.filename, mediaType: p.mime, data: p.url, size: Buffer.from(p.url.slice(p.url.indexOf(",") + 1), "base64").length }));
+                messages.push({ role: "user", content: [{ type: "text", text }, ...attachmentContent(attachments)], timestamp: Date.parse(info.time.created) || Date.now() });
             }
             else {
                 const text = parts
@@ -831,6 +980,8 @@ export async function createFrameworkSession(input) {
         permission: input.permission ?? [],
         ...(input.writePaths?.length ? { writePaths: input.writePaths } : {}),
         queuedPrompts: [],
+        ...(input.creationRequestId ? { creationRequestId: input.creationRequestId } : {}),
+        ...(input.creationPayloadHash ? { creationPayloadHash: input.creationPayloadHash } : {}),
         time: { created: new Date().toISOString(), updated: new Date().toISOString() },
     };
     await input.store.createSession(session);
@@ -839,6 +990,13 @@ export async function createFrameworkSession(input) {
 export function isSessionActive(sessionId) {
     return activeRuns.has(sessionId);
 }
+/** 会话当前 run 是否挂起等待人工授权（HITL 待确认）。宿主会话列表用它把
+ *  「待确认」从笼统的「运行中」里区分出来，否则后台会话被权限卡住时
+ *  侧边栏毫无信号。无 run 或 run 无 pending 请求均为 false。 */
+export function isSessionAwaitingPermission(sessionId) {
+    const active = activeRuns.get(sessionId);
+    return !!active && active.engine.pendingRequests.length > 0;
+}
 /** 当前所有 running 会话 id（Electron 优雅退出等收尾场景枚举用，P2）。
  *  activeRuns 是模块级 globalThis 单例，跨项目/跨 runtime 共享。 */
 export function listActiveSessions() {