personal-bot 0.2.4 → 0.2.5

package/lib/extension/dsh/agent-runtime.js

@@ -0,0 +1,348 @@
+import { foldConsumedWork } from "@deepseek-ai/dsh-agent";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { AgentRun } from "../../services/agents/agent-run.js";
+import { AgentFiles, launch } from "../../storage/agent-files.js";
+import { requireThat } from "../../common/validation.js";
+import { dshInput, dshHumanInput } from "../../integrations/dsh/input.js";
+import { requestSource, finalDshAnswer } from "../../integrations/dsh/messages.js";
+import { flushDshAgent } from "../../integrations/dsh/session.js";
+import { createTeamContext, teamBrief } from "../../integrations/team-context.js";
+/** One expert's native event adapter. AgentRun and TeamService own durable business state. */
+export class DshAgentRuntime {
+    ctx;
+    agent;
+    d;
+    generation;
+    files;
+    teams;
+    owner;
+    execution;
+    #lifetime = new AbortController();
+    #inbox = { "next-turn": [], "next-step": [] };
+    #seen = new Map();
+    #events = Promise.resolve();
+    #turnEvents = [];
+    #answer = "";
+    #hasAnswer = false;
+    #activeTeam;
+    #pendingPause;
+    #pump;
+    #timer;
+    #stopping;
+    #closing = false;
+    #failure;
+    #ready = false;
+    #teamTool = false;
+    constructor(ctx, agent, d, generation, files, teams, owner) {
+        this.ctx = ctx;
+        this.agent = agent;
+        this.d = d;
+        this.generation = generation;
+        this.files = files;
+        this.teams = teams;
+        this.owner = owner;
+        this.execution = new AgentRun(files, d.agentId, generation);
+    }
+    check = () => {
+        this.#lifetime.signal.throwIfAborted();
+        this.owner.check();
+        this.files.check();
+        const run = this.files.read(this.d.agentId, "launch.json", launch);
+        requireThat(run.generation === this.generation && !run.stop, "专家已停止或启动代次变化。");
+    };
+    actor = () => ({ kind: "member", agentId: this.d.agentId, generation: this.generation,
+        ...(this.#activeTeam && this.execution.current?.source === "parent" ? { requestId: this.#activeTeam.request.requestId } : {}) });
+    current() { return this.files.read(this.d.agentId, "launch.json", launch).generation === this.generation; }
+    pause(reason) {
+        this.#pendingPause = reason;
+        try {
+            this.teams.pauseMember(this.d.agentId, reason);
+            this.#pendingPause = undefined;
+        }
+        catch (error) {
+            if (error.code !== "PBOT_CONTROL_BUSY")
+                throw error;
+        }
+    }
+    enqueue(work) {
+        this.#events = this.#events.then(work).catch(error => this.fail(error));
+    }
+    fail(error) {
+        if (this.#failure)
+            return;
+        this.#failure = error;
+        this.#lifetime.abort();
+        try {
+            if (this.current()) {
+                this.teams.files.setReady(this.d.agentId, this.generation, false);
+                this.execution.save({ state: "error", activity: "控制失败", error: String(error) });
+                this.pause("专家控制失败");
+            }
+        }
+        catch (failure) {
+            this.ctx.logger.error("pbot 专家状态保存失败", failure);
+        }
+        void this.owner.release().catch(failure => this.ctx.logger.error("pbot 专家释放失败", failure));
+    }
+    initialize(teamTool) {
+        this.check();
+        this.#teamTool = teamTool;
+        this.teams.files.setReady(this.d.agentId, this.generation, false);
+        this.pause("专家载入：旧批次不自动恢复");
+        this.execution.recover();
+        for (const event of this.agent.session.snapshotEvents())
+            if (event.type === "user/message" && event.data.source.kind === "pbot-team-context") {
+                const { teamId, seqs } = event.data.source, seen = this.#seen.get(teamId) ?? new Set();
+                for (const seq of seqs)
+                    seen.add(seq);
+                this.#seen.set(teamId, seen);
+            }
+        this.ctx.on("session/event", (session, event) => {
+            if (session === this.agent.session)
+                this.enqueue(() => this.event(event));
+        });
+        this.ctx.on("agent/status", ({ agent, status }) => {
+            if (agent !== this.agent)
+                return;
+            this.enqueue(() => {
+                if (!this.current() || this.#closing || this.#failure)
+                    return;
+                this.execution.save({ state: status === "idle" ? "idle" : "busy", activity: status === "idle" ? "空闲" : "执行" });
+            });
+        });
+        this.ctx.on("agent/pre-step", async (_payload, next) => {
+            await this.#events;
+            this.check();
+            if (this.#activeTeam && !this.humanPending() && this.execution.current?.source === "parent" && Date.now() >= this.#activeTeam.run.deadlineAt) {
+                this.pause("已到期限");
+                this.agent.cancel({ kind: "hook", reason: "团队请求已到期限" });
+                return { kind: "reject" };
+            }
+            const decision = await next();
+            this.check();
+            if (decision.kind !== "enter" || !this.#activeTeam || this.execution.current?.source !== "parent" || this.humanPending() ||
+                decision.messages.some(message => message.source.kind === "user"))
+                return decision;
+            const link = this.teams.links().get(this.#activeTeam.request.requestId);
+            requireThat(link, "团队关联不可读取。");
+            const seen = this.#seen.get(link.team.teamId) ?? new Set();
+            const context = createTeamContext(link, seen);
+            if (!context)
+                return decision;
+            return { ...decision, messages: [...decision.messages, createUserMessage({ content: [{ type: "text", text: context.content }],
+                        source: { kind: "pbot-team-context", form: "relay", teamId: link.team.teamId, seqs: context.seqs } })] };
+        });
+        this.ctx.systemPrompt.section({ name: "pbot:team", order: 600, interpolate: false,
+            text: () => this.#activeTeam && !this.humanPending() && this.execution.current?.source === "parent" ? teamBrief(this.#activeTeam) : "" });
+        this.execution.save({ state: "idle", activity: "空闲" });
+        this.ctx.effect(() => () => this.stop());
+    }
+    /** Called only after native Agent creation has resolved, never from setup. */
+    start() {
+        this.check();
+        this.#timer = setInterval(() => { void this.pump(); }, 250);
+        this.#timer.unref();
+        void this.pump();
+    }
+    async interact(text, delivery = "steer", files = [], attachments = [], caller) {
+        this.check();
+        requireThat((text.trim().length > 0 || files.length || attachments.length) && text.length <= 24000, "请输入消息或附加文件；消息最多 24000 字符。");
+        const signal = caller ? AbortSignal.any([caller, this.#lifetime.signal]) : this.#lifetime.signal;
+        const message = await dshHumanInput(this.ctx, this.d.cwd, text, files, attachments, signal);
+        this.check();
+        signal.throwIfAborted();
+        this.teams.pauseMember(this.d.agentId, "成员由人工接管");
+        if (delivery === "followUp")
+            this.agent.followup(message);
+        else
+            this.agent.steer(message);
+        // Native inbox admission transfers ownership to the expert, independently of the UI request.
+        await flushDshAgent(this.agent);
+        return { status: "queued", messageId: message.id };
+    }
+    async event(event) {
+        if (!this.current())
+            return;
+        if (event.type === "turn/start") {
+            this.#turnEvents = [];
+            this.#answer = "";
+            this.#hasAnswer = false;
+            this.execution.begin();
+        }
+        if (this.execution.current)
+            this.#turnEvents.push(event);
+        if (event.type === "agent/inbox/spliced") {
+            const change = event.data;
+            const removed = this.#inbox[change.target].splice(change.start, change.removedCount ?? 0, ...change.inserted);
+            if (change.inserted.some(message => message.source.kind === "user"))
+                this.pause("成员由人工接管");
+            for (const message of removed) {
+                if (message.source.kind === "user" && change.outcome !== "canceled")
+                    this.execution.enterHuman();
+                const source = requestSource(message, this.generation);
+                if (!source)
+                    continue;
+                if (change.outcome === "canceled") {
+                    this.execution.cancelQueued(source.requestId);
+                    if (this.#activeTeam?.request.requestId === source.requestId && !this.execution.current?.requestIds.includes(source.requestId))
+                        this.#activeTeam = undefined;
+                }
+                else
+                    this.execution.enter(source.requestId);
+            }
+        }
+        if (event.type === "user/message") {
+            const source = requestSource(event.data, this.generation);
+            if (source)
+                this.execution.consume(source.requestId);
+            if (event.data.source.kind === "user")
+                this.execution.humanInput();
+            if (event.data.source.kind === "pbot-team-context") {
+                const { teamId, seqs } = event.data.source, seen = this.#seen.get(teamId) ?? new Set();
+                for (const seq of seqs)
+                    seen.add(seq);
+                this.#seen.set(teamId, seen);
+            }
+        }
+        if (event.type === "assistant/message") {
+            this.#answer = finalDshAnswer(event);
+            this.#hasAnswer = true;
+        }
+        if (event.type === "turn/end") {
+            const accounted = foldConsumedWork(this.#turnEvents).end?.seq === event.seq;
+            await flushDshAgent(this.agent);
+            const reason = event.data.reason;
+            this.execution.finish({
+                state: reason.kind === "aborted" ? "cancelled" : reason.kind === "interrupted" || reason.kind === "forked" ? "interrupted"
+                    : reason.kind === "completed" && accounted ? "completed" : "failed",
+                position: this.#hasAnswer ? "dsh:" + event.seq : null,
+                answer: this.#answer,
+                ...(reason.kind === "error" ? { error: reason.error.message } : !["completed", "aborted"].includes(reason.kind) ? { error: reason.kind } : {}),
+            });
+            this.#activeTeam = undefined;
+            this.#turnEvents = [];
+        }
+    }
+    humanPending() { return [...this.agent.inbox.nextTurn, ...this.agent.inbox.nextStep].some(message => message.source.kind === "user"); }
+    pump() {
+        if (this.#pump || this.#closing)
+            return this.#pump ?? Promise.resolve();
+        this.#pump = this.deliver().catch(error => {
+            if (error.code === "PBOT_CONTROL_BUSY" || (this.#closing && this.#lifetime.signal.aborted))
+                return;
+            this.fail(error);
+        }).finally(() => { this.#pump = undefined; });
+        return this.#pump;
+    }
+    async deliver() {
+        const run = this.files.read(this.d.agentId, "launch.json", launch);
+        if (run.generation !== this.generation || run.stop) {
+            void this.owner.release().catch(error => this.fail(error));
+            return;
+        }
+        await this.#events;
+        this.check();
+        if (this.#pendingPause) {
+            this.pause(this.#pendingPause);
+            if (this.#pendingPause)
+                return;
+        }
+        const capable = this.#teamTool && !!this.ctx.tools.get("pbot_team_message", this.agent);
+        if (capable !== this.#ready) {
+            this.teams.files.setReady(this.d.agentId, this.generation, capable);
+            this.#ready = capable;
+            if (!capable)
+                this.pause("成员团队工具已停用");
+        }
+        if (this.#activeTeam) {
+            if (Date.now() >= this.#activeTeam.run.deadlineAt) {
+                this.pause("已到期限");
+                if (!this.humanPending() && !this.execution.interactive && this.execution.current?.source !== "mixed" && this.execution.current?.source !== "interactive")
+                    this.agent.cancel({ kind: "hook", reason: "团队请求已到期限" });
+            }
+            return;
+        }
+        const links = this.teams.links();
+        const idle = () => this.agent.status === "idle" && !this.agent.inbox.nextTurn.length && !this.agent.inbox.nextStep.length && !this.execution.current && !this.execution.pending && !this.execution.interactive;
+        for (const request of this.files.messages(this.d.agentId)) {
+            if (request.generation !== this.generation || this.execution.accepted(request.requestId))
+                continue;
+            const link = links.get(request.requestId);
+            if (link && (link.team.closed || link.run.state !== "running" || link.run.deadlineAt <= Date.now()))
+                continue;
+            if (link && !idle())
+                break;
+            const message = await dshInput(this.ctx, this.d, request, this.#lifetime.signal);
+            this.check();
+            const submit = async () => {
+                this.check();
+                const accept = () => this.execution.claim(request.requestId);
+                if (link) {
+                    if (!idle())
+                        return;
+                    this.#activeTeam = this.teams.claim(this.d.agentId, this.generation, request.requestId, accept);
+                    if (!this.#activeTeam)
+                        return;
+                }
+                else
+                    accept();
+                if (request.delivery === "followUp")
+                    this.agent.followup(message);
+                else
+                    this.agent.steer(message);
+                await flushDshAgent(this.agent);
+            };
+            if (link) {
+                // Public status stays idle during native maintenance. Its idle admission is authoritative.
+                let entered = false;
+                try {
+                    await this.agent.runMaintenance(async (signal) => { entered = true; signal.throwIfAborted(); await submit(); });
+                }
+                catch (error) {
+                    if (entered)
+                        throw error;
+                    this.check();
+                }
+            }
+            else
+                await submit();
+            break;
+        }
+    }
+    stop() {
+        if (this.#stopping)
+            return this.#stopping;
+        this.#closing = true;
+        this.#lifetime.abort();
+        if (this.#timer)
+            clearInterval(this.#timer);
+        this.#timer = undefined;
+        this.#stopping = (async () => {
+            try {
+                if (this.current()) {
+                    this.files.control(() => {
+                        const run = this.files.read(this.d.agentId, "launch.json", launch);
+                        if (run.generation === this.generation && !run.stop) {
+                            run.stop = true;
+                            this.files.write(this.d.agentId, "launch.json", run, launch);
+                        }
+                    });
+                    this.teams.files.setReady(this.d.agentId, this.generation, false);
+                    this.#ready = false;
+                    this.pause("专家停止");
+                    if (!this.#failure)
+                        this.execution.save({ state: "stopping", activity: "停止" });
+                }
+            }
+            finally {
+                this.agent.cancel({ kind: "disposed" });
+            }
+            await this.agent.whenIdle();
+            await this.#pump;
+            await this.#events;
+            if (this.current() && !this.#failure)
+                this.execution.save({ state: "stopped", activity: "已停止" });
+        })();
+        return this.#stopping;
+    }
+}

package/lib/extension/dsh/command.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from "@deepseek-ai/cordis";
+import { type PbotManagement } from "./management.js";
+import type { DshWorkspaces } from "./workspace.js";
+export declare function registerDshCommand(ctx: Context, workspaces: DshWorkspaces, management: PbotManagement): void;

package/lib/extension/dsh/command.js

@@ -0,0 +1,83 @@
+import { Type } from "typebox";
+import { object, json } from "../../common/json.js";
+import { requireThat, schema } from "../../common/validation.js";
+import { prepareWorkspace } from "../../services/workspace/workspace-preparation.js";
+import { executeAgent } from "../../tools/agents/actions.js";
+import { dshAgentActionSchema } from "../../tools/agents/dsh-contract.js";
+import { executeTeam, executeTeamMessage } from "../../tools/teams/actions.js";
+import { teamActionSchema, teamParametersSchema, teamMessageActionSchema, teamMessageParametersSchema } from "../../tools/teams/contract.js";
+import { dshStatus } from "./management.js";
+const validAgent = schema(dshAgentActionSchema), validTeam = schema(teamActionSchema), validMessage = schema(teamMessageActionSchema);
+const chatSchema = Type.Object({ agentId: Type.String({ minLength: 1 }), text: Type.Optional(Type.String({ maxLength: 24000 })),
+    delivery: Type.Optional(Type.Union([Type.Literal("steer"), Type.Literal("followUp")])),
+    files: Type.Optional(Type.Array(Type.String({ minLength: 1 }), { maxItems: 32 })) }, { additionalProperties: false });
+const validChat = schema(chatSchema);
+const usage = '用法：/pbot status | init | python setup | agent {"action":…} | chat {"agentId":…,"text":…} | team {"action":…} | post {"teamId":…,"text":…} | history {"action":…} | records {"agentId":…}';
+export function registerDshCommand(ctx, workspaces, management) {
+    ctx.commands.register({ name: "pbot", description: "Personal Bot 工作区与协作管理", recordInput: false,
+        input: { hint: "status | init | python setup | agent/chat/team/post/history/records JSON", attachments: true },
+        async handler({ agent, rawInput, signal, attachments, commandId }) {
+            signal.throwIfAborted();
+            const workspace = await workspaces.get(agent);
+            signal.throwIfAborted();
+            const command = rawInput.trim(), split = command.search(/\s/);
+            const verb = split < 0 ? command : command.slice(0, split);
+            requireThat(verb === "chat" || !attachments.length, "输入框附件仅用于 chat 人工对话。");
+            if (command === "init") {
+                await prepareWorkspace(workspace.root);
+                workspace.check();
+                return { kind: "success", text: "资料目录已准备；已有文件保留。" };
+            }
+            if (command === "python setup") {
+                const result = await workspaces.preparePython();
+                workspace.check();
+                return { kind: "success", text: JSON.stringify(result, null, 2) };
+            }
+            if (!command || command === "status")
+                return { kind: "success", text: JSON.stringify(dshStatus(workspaces, workspace), null, 2) };
+            requireThat(split >= 0, usage);
+            const input = JSON.parse(command.slice(split));
+            requireThat(object(input), "命令参数必须是 JSON 对象。");
+            let result;
+            switch (verb) {
+                case "agent": {
+                    requireThat(validAgent(input), "dsh 专家参数无效或包含不支持的宿主选项。");
+                    const selection = agent.model.current();
+                    const output = await executeAgent(workspace.agents, input, workspace.owner, selection ? {
+                        provider: selection.provider, model: selection.model,
+                        ...(selection.reasoningEffort && (!input.provider || input.provider === selection.provider) && (!input.model || input.model === selection.model)
+                            ? { thinking: selection.reasoningEffort } : {}),
+                    } : {});
+                    result = output.structuredContent;
+                    break;
+                }
+                case "chat": {
+                    requireThat(validChat(input), "人工对话参数无效。");
+                    const args = input;
+                    result = await workspace.expert(args.agentId).interact(args.text ?? "", args.delivery, args.files, attachments, signal);
+                    break;
+                }
+                case "team": {
+                    requireThat(validTeam(input), "团队参数无效。");
+                    result = executeTeam(workspace.teams, workspace.agents, input, workspace.owner).structuredContent;
+                    break;
+                }
+                case "post": {
+                    const args = { ...input, action: "post" };
+                    requireThat(input.action === undefined && validMessage(args), "公共消息参数无效。");
+                    result = executeTeamMessage(workspace.teams, args, { kind: "user", owner: workspace.owner }, commandId).structuredContent;
+                    break;
+                }
+                case "history":
+                    result = await management.history({ parentSessionId: agent.id, input: json(input) }, signal);
+                    break;
+                case "records":
+                    result = await management.expert({ parentSessionId: agent.id, input: json(input) }, signal);
+                    break;
+                default: throw new Error(usage);
+            }
+            workspace.check();
+            return { kind: "success", text: JSON.stringify(result, null, 2) };
+        },
+    });
+}

package/lib/extension/dsh/files.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+/** Native filesystem mutations share the original workspace's confirmation rule.
+ * This does not confine Bash, Python, MCP, or other extensions. */
+export declare function registerDshFileEvents(ctx: Context, agent: Agent, root: string, expert: boolean, check: () => void): void;

package/lib/extension/dsh/files.js

@@ -0,0 +1,67 @@
+import { parsePatch } from "@deepseek-ai/dsh-fs-patch";
+import { object } from "../../common/json.js";
+import { requireThat } from "../../common/validation.js";
+import { mutationScope } from "../../services/workspace/workspace-files.js";
+/** Native filesystem mutations share the original workspace's confirmation rule.
+ * This does not confine Bash, Python, MCP, or other extensions. */
+export function registerDshFileEvents(ctx, agent, root, expert, check) {
+    const lifetime = new AbortController();
+    const mutations = new Set(["write", "edit", "apply_patch"]);
+    const captured = new Map();
+    ctx.effect(() => () => { lifetime.abort(); captured.clear(); });
+    async function targets(exec) {
+        check();
+        const args = exec.arguments;
+        requireThat(exec.agent === agent && object(args), "文件操作会话或参数无效。");
+        const signal = AbortSignal.any([lifetime.signal, exec.signal]);
+        signal.throwIfAborted();
+        let paths;
+        if (exec.name === "apply_patch") {
+            requireThat(typeof args.input === "string", "补丁参数无效。");
+            paths = parsePatch(args.input).flatMap(operation => [operation.path, ...(operation.kind === "update" && operation.moveTo ? [operation.moveTo] : [])]);
+        }
+        else {
+            requireThat(typeof args.file_path === "string" && args.file_path.trim().length > 0, "文件路径无效。");
+            paths = [args.file_path];
+        }
+        const anchor = ctx.fs.processPathFromHostPath(root);
+        requireThat(anchor !== undefined, "原生文件系统未映射当前工作区。");
+        const cwd = ctx.workingDirectory.get(agent.session);
+        const resolved = await Promise.all(paths.map(path => ctx.fs.resolve(path, { cwd, signal })));
+        signal.throwIfAborted();
+        check();
+        const outside = resolved.map(target => ctx.fs.processPath(target)).filter(path => mutationScope(anchor, path) === "outside");
+        return { cwd, keys: resolved.map(target => target.targetKey), outside, signal };
+    }
+    ctx.on("tools/pre-execute", async (exec, next) => {
+        if (!mutations.has(exec.name))
+            return next();
+        const value = await targets(exec), record = { cwd: value.cwd, keys: value.keys, approved: !value.outside.length };
+        captured.set(exec.token, record);
+        if (value.outside.length && expert)
+            return { kind: "deny", reason: "专家不能修改工作区外文件。" };
+        const policy = await next();
+        value.signal.throwIfAborted();
+        check();
+        if (policy.kind === "deny" || policy.kind === "cancel" || !value.outside.length)
+            return policy;
+        const scopeReason = "Personal Bot: confirm changes outside the original workspace: " + JSON.stringify(value.outside);
+        const reason = [policy.kind === "ask" ? policy.reason : undefined, scopeReason].filter(Boolean).join("\n");
+        const outcome = await ctx.approval.request({ agent, toolName: exec.name, callId: exec.callId, signal: value.signal, reason,
+            displayReason: { en: reason, "zh-CN": "允许本次修改原工作区之外的文件：" + value.outside.join("、") + (policy.kind === "ask" && policy.reason ? "\n" + policy.reason : "") } });
+        value.signal.throwIfAborted();
+        check();
+        record.approved = outcome === "allowed-once";
+        return record.approved ? { kind: "allow" } : { kind: "deny", reason: "用户未确认文件修改。" };
+    });
+    ctx.on("tools/execute", async (exec, next) => {
+        if (!mutations.has(exec.name))
+            return next();
+        const record = captured.get(exec.token);
+        requireThat(record?.approved, "文件操作没有有效的范围检查或确认。");
+        const value = await targets(exec);
+        requireThat(record.cwd === value.cwd && record.keys.length === value.keys.length && record.keys.every((key, index) => key === value.keys[index]), "确认期间文件路径或工作目录已变化。");
+        return next();
+    });
+    ctx.on("tools/result", exec => { captured.delete(exec.token); });
+}

package/lib/extension/dsh/history.d.ts

@@ -0,0 +1,15 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import { HistoryService } from "../../services/history/history-service.js";
+/** One server-owned organizer per workspace, shared by its parent Sessions. */
+export declare class DshHistoryWork {
+    #private;
+    private readonly ctx;
+    readonly service: HistoryService;
+    constructor(ctx: Context, root: string);
+    attach(agent: Agent): () => void;
+    cancel(): void;
+    schedule(agent: Agent): void;
+    close(): Promise<void>;
+}
+export declare function registerDshHistoryEvents(ctx: Context, agent: Agent, work: DshHistoryWork, check: () => void): void;

package/lib/extension/dsh/history.js

@@ -0,0 +1,88 @@
+import { join } from "node:path";
+import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
+import { AgentFiles } from "../../storage/agent-files.js";
+import { HistoryFiles } from "../../storage/history-files.js";
+import { HistoryService } from "../../services/history/history-service.js";
+import { DshHistory } from "../../integrations/dsh/history.js";
+import { dshHistorySummarizer } from "../../integrations/dsh/history-summary.js";
+import { finalDshAnswer } from "../../integrations/dsh/messages.js";
+/** One server-owned organizer per workspace, shared by its parent Sessions. */
+export class DshHistoryWork {
+    ctx;
+    service;
+    #parents = new Set();
+    #controller;
+    #work;
+    #closing;
+    constructor(ctx, root) {
+        this.ctx = ctx;
+        const agents = new AgentFiles(dshHomePath("pbot", "subagents"), "dsh");
+        this.service = new HistoryService(root, new HistoryFiles(join(root, ".dsh/pbot/history"), "dsh"), new DshHistory(ctx, root, () => agents.list().filter(value => value.workspace === root).map(value => value.agentId)), undefined, new HistoryFiles(join(root, ".pi/pbot/history")));
+    }
+    attach(agent) { this.#parents.add(agent); return () => { this.#parents.delete(agent); }; }
+    cancel() { this.#controller?.abort(); }
+    schedule(agent) {
+        if (this.#closing || [...this.#parents].some(parent => parent.status !== "idle" || parent.inbox.nextTurn.length || parent.inbox.nextStep.length))
+            return;
+        this.cancel();
+        const controller = new AbortController(), selection = agent.model.current(), sessionId = agent.id;
+        this.#controller = controller;
+        const signal = controller.signal;
+        const work = (this.#work ?? Promise.resolve()).catch(() => { }).then(async () => {
+            signal.throwIfAborted();
+            await this.service.refresh({ host: "dsh", sessionId }, signal);
+            signal.throwIfAborted();
+            await this.service.organize(dshHistorySummarizer(this.ctx, selection, sessionId), signal);
+        }).catch(error => { if (!signal.aborted)
+            this.ctx.logger.warn("pbot 历史整理未完成：" + String(error)); });
+        this.#work = work;
+        void work.finally(() => { if (this.#work === work) {
+            this.#work = undefined;
+            this.#controller = undefined;
+        } });
+    }
+    close() {
+        if (this.#closing)
+            return this.#closing;
+        this.cancel();
+        this.#closing = (async () => { await this.#work; await this.service.close(); this.#parents.clear(); })();
+        return this.#closing;
+    }
+}
+export function registerDshHistoryEvents(ctx, agent, work, check) {
+    let normal = false, final = false;
+    ctx.effect(() => work.attach(agent));
+    ctx.on("session/event", (session, event) => {
+        if (session !== agent.session)
+            return;
+        if (event.type === "turn/start") {
+            normal = false;
+            final = false;
+        }
+        if (event.type === "assistant/message")
+            final = Boolean(finalDshAnswer(event).trim());
+        if (event.type === "agent/inbox/spliced" && event.data.inserted.some(message => message.source.kind === "user")) {
+            normal = false;
+            work.cancel();
+        }
+        if (event.type === "turn/end")
+            normal = event.data.reason.kind === "completed" && final;
+    });
+    ctx.on("agent/pre-step", async (_payload, next) => { work.cancel(); check(); return next(); });
+    ctx.on("agent/status", ({ agent: changed, status }) => {
+        if (changed !== agent || status !== "idle" || !normal)
+            return;
+        normal = false;
+        if (!agent.inbox.nextTurn.length && !agent.inbox.nextStep.length) {
+            try {
+                check();
+            }
+            catch (error) {
+                if (error.name === "AbortError")
+                    return;
+                throw error;
+            }
+            work.schedule(agent);
+        }
+    });
+}

package/lib/extension/dsh/management.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from "@deepseek-ai/cordis";
+import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { type Json } from "../../common/json.js";
+import type { DshWorkspaces, DshWorkspace } from "./workspace.js";
+export declare function dshStatus(workspaces: DshWorkspaces, workspace: DshWorkspace): Json;
+/** Native Remote owns transport and access checks. These workspace reads do not admit or cancel execution. */
+export declare class PbotManagement extends TypertRemoteService {
+    private readonly workspaces;
+    constructor(ctx: Context, workspaces: DshWorkspaces);
+    private workspace;
+    snapshot(request: Json, signal: AbortSignal): Promise<Json>;
+    expert(request: Json, signal: AbortSignal): Promise<Json>;
+    team(request: Json, signal: AbortSignal): Promise<Json>;
+    history(request: Json, signal: AbortSignal): Promise<Json>;
+}
+declare module "@deepseek-ai/cordis" {
+    interface Context {
+        pbotManagement: PbotManagement;
+    }
+}
+export declare function registerDshManagement(ctx: Context, workspaces: DshWorkspaces): PbotManagement;