@lemoncat7/dsh-partner 1.8.2 → 1.9.2

package/lib/agent-runtime.js

@@ -3,6 +3,9 @@ import { mkdir, realpath, stat, writeFile } from 'node:fs/promises';
 import { basename, extname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { BlockAssembler, createToolResultMessage, createUserMessage } from '@deepseek-ai/dsh-llm';
 import { createScope, scopeOf, scopeParentOf } from '@deepseek-ai/dsh-scope';
+import { SessionConfigurationIndex } from './companions/session-configuration.js';
+import { removeOwnedWorkspace } from './companions/workspace-cleanup.js';
+import { assertOwnedDirectory, removeOwnedDirectory } from './companions/directory-cleanup.js';
 import { concernObservationPrompt } from './autonomy.js';
 import { boundedConcernCheckMinutes } from './concern-domain.js';
 import { PARTNER_MEDIA_MAX_BYTES, safeMediaName } from './channel-message.js';
@@ -10,6 +13,7 @@ import { listConcernFileSources } from './concern-sources.js';
 import { CONCERN_CREATED_NOTICE, renderConcernCreatedNotice } from './concern-notification.js';
 import { HEARTBEAT_LOCAL_COMMAND, heartbeatLocalCommandTool } from './heartbeat-command.js';
 import { assistantTextAfter, renderPartnerPersona, renderToolProtocol, resolvePartnerAgentOptions as resolveAgentOptions } from './execution/agent-support.js';
+import { channelReplyTextAfter } from './channels/delivery-policy.js';
 export { renderToolProtocol, resolvePartnerAgentOptions as resolveAgentOptions } from './execution/agent-support.js';
 const HEARTBEAT_TIMEOUT_MS = 115_000;
 const HEARTBEAT_DISCOVERY_BUDGET_MS = 72_000;
@@ -54,6 +58,12 @@ export class PartnerAgentRuntime {
     restoredCompositions = new Map();
     restoredCompositionJobs = new Map();
     disposeAgentListener;
+    disposeConfigurationListener;
+    configurations;
+    preparedTurns = new WeakMap();
+    observationJobs = new Map();
+    agentSetupJobs = new Map();
+    closed = false;
     questionAnswerer;
     constructor(ctx, store, defaultCwd, memory, reflection, concerns, composer) {
         this.ctx = ctx;
@@ -63,8 +73,15 @@ export class PartnerAgentRuntime {
         this.reflection = reflection;
         this.concerns = concerns;
         this.composer = composer;
+        this.configurations = new SessionConfigurationIndex(store);
+        this.disposeConfigurationListener = typeof this.ctx.on === 'function'
+            ? this.ctx.on('agent/pre-step', async ({ agent, turn, signal }, next) => {
+                await this.prepareAgentTurn(agent, turn, signal);
+                return next();
+            }) : () => { };
         this.disposeAgentListener = typeof this.ctx.on === 'function'
             ? this.ctx.on('agent/disposed', ({ agent }) => {
+                this.preparedTurns.delete(agent);
                 const restored = this.restoredCompositions.get(agent.session.id);
                 if (restored?.agent !== agent)
                     return;
@@ -145,6 +162,8 @@ export class PartnerAgentRuntime {
         return route;
     }
     async ensureLocalSessionRecord(companionId) {
+        if (this.store.isCompanionRemoving(companionId))
+            throw new Error('伙伴正在删除，不能创建会话');
         const companion = this.store.snapshot().companions.find(item => item.id === companionId);
         if (companion === undefined)
             throw new Error('伙伴身份不存在');
@@ -164,6 +183,8 @@ export class PartnerAgentRuntime {
             lastMessageAt: now,
         };
         await this.store.update(state => {
+            if (this.store.isCompanionRemoving(companion.id) || !state.companions.some(item => item.id === companion.id))
+                throw new Error('伙伴正在删除或已不存在');
             state.sessions = state.sessions.filter(item => !(item.companionId === companion.id && item.kind === 'local'));
             state.sessions.push(route);
         });
@@ -191,9 +212,9 @@ export class PartnerAgentRuntime {
         const agent = await this.ensureAgent(companion, route);
         const isReviewer = task.status === 'review' && task.reviewerCompanionId === companion.id;
         const instruction = isReviewer
-            ? '这是你创建并分配的看板任务，执行伙伴已提交结果，现在默认由你验收。请根据任务要求真实核验已有产出；通过后必须调用 partner_task_board accept，不通过则调用 reject 并写明原因。不要重新执行该任务。'
+            ? '这是伙伴内部验收，不是用户的新消息。执行伙伴已提交结果，现在默认由你验收。请根据任务要求真实核验已有产出；通过后必须调用 partner_task_board accept，不通过则调用 reject 并写明原因。不要重新执行该任务，不要向用户播报核验过程或 accept 操作；最终结果由系统直接投递。'
             : task.status === 'review'
-                ? '这是你创建并分配的看板任务进度事件。执行结果已提交并等待指定伙伴验收；不要重新执行，请向用户简要说明当前进度。'
+                ? '这是伙伴内部进度事件。执行结果已提交并等待指定伙伴验收；不要重新执行，也不要向用户播报中间进度。只在看板中推进必要的协作，最终结果由系统直接投递。'
                 : task.status === 'done'
                     ? '这是你创建并分配的看板任务终态事件。不要重新执行已完成的工作。请检查依赖它的后续任务是否解锁，需要时继续在看板上分配。对用户的终态结果由系统直接投递，不要只改写成“已完成”或进度摘要。'
                     : '这是你创建并分配的看板任务受阻事件。请保留已有产出、检查是否能调整分工或解锁依赖；需要用户介入时，明确说明阻塞原因与所需动作。';
@@ -364,6 +385,25 @@ export class PartnerAgentRuntime {
         }
     }
     async observeSessionEvent(session, event) {
+        if (event.type !== 'turn/end' || event.data.reason.kind !== 'completed')
+            return;
+        const route = this.store.snapshot().sessions.find(item => item.sessionId === session.id);
+        if (!route || this.store.isCompanionRemoving(route.companionId))
+            return;
+        const id = route.companionId;
+        this.observationJobs.set(id, (this.observationJobs.get(id) ?? 0) + 1);
+        try {
+            await this.processSessionEvent(session, event);
+        }
+        finally {
+            const left = (this.observationJobs.get(id) ?? 1) - 1;
+            if (left)
+                this.observationJobs.set(id, left);
+            else
+                this.observationJobs.delete(id);
+        }
+    }
+    async processSessionEvent(session, event) {
         if (event.type !== 'turn/end' || event.data.reason.kind !== 'completed')
             return;
         const route = this.store.snapshot().sessions.find(item => item.sessionId === session.id);
@@ -476,35 +516,65 @@ export class PartnerAgentRuntime {
         await this.releaseCompanion(companionId);
         await this.store.update(state => { state.sessions = state.sessions.filter(item => item.companionId !== companionId); });
     }
+    async removeCompanionWorkspace(companionId) {
+        const cwd = partnerCwd(this.defaultCwd, companionId);
+        const sharedPaths = this.store.snapshot().sessions.filter(route => route.companionId !== companionId).map(route => route.cwd ?? this.defaultCwd);
+        await removeOwnedWorkspace(this.ctx.workspaceRegistry, cwd, companionId, sharedPaths);
+        this.workspaces.delete(cwd);
+    }
+    sharedDirectoryPaths(companionId) {
+        const state = this.store.snapshot();
+        const cwd = resolve(partnerCwd(this.defaultCwd, companionId));
+        return [
+            ...state.companions.filter(item => item.id !== companionId).map(item => partnerCwd(this.defaultCwd, item.id)),
+            ...state.sessions.filter(route => route.companionId !== companionId).map(route => route.cwd ?? this.defaultCwd),
+            ...this.ctx.workspaceRegistry.list().filter(item => resolve(item.path) !== cwd).map(item => item.path),
+        ];
+    }
+    async validateCompanionDirectory(companionId) {
+        await assertOwnedDirectory(this.defaultCwd, companionId, this.sharedDirectoryPaths(companionId));
+    }
+    async removeCompanionDirectory(companionId) {
+        await removeOwnedDirectory(this.defaultCwd, companionId, this.sharedDirectoryPaths(companionId));
+    }
     async reloadCompanion(companionId) {
-        if (this.isCompanionBusy(companionId))
-            throw new Error('伙伴正在执行，请等待当前回复结束后再修改能力');
-        const activeRoutes = this.store.snapshot().sessions.filter(route => route.companionId === companionId
-            && (this.handles.has(route.sessionId) || this.ctx.agents.get(route.sessionId) !== undefined));
-        await this.releaseCompanion(companionId);
-        // Releasing a restored composition does not close the browser-owned Agent.
-        // Recompose it now: staying in the same conversation must not leave it with
-        // no partner tools until the user happens to click "open session" again.
-        for (const route of activeRoutes) {
-            const state = this.store.snapshot();
-            const companion = state.companions.find(item => item.id === companionId);
-            const currentRoute = state.sessions.find(item => item.id === route.id && item.companionId === companionId);
-            if (companion && currentRoute)
-                await this.ensureAgent(companion, currentRoute);
-        }
+        // Compatibility for callers that saved a configuration. The index already
+        // observes committed writes; do not tear down or wake any Agent here.
+        if (!this.configurations.companion(companionId))
+            throw new Error('伙伴不存在');
     }
-    async reloadManagedCompanion(companionId) {
-        const externallyOwned = this.store.snapshot().sessions.some(route => route.companionId === companionId
-            && !this.handles.has(route.sessionId) && this.ctx.agents.get(route.sessionId) !== undefined);
-        await this.reloadCompanion(companionId);
-        // Browser-owned handles cannot be disposed by this plugin. In particular,
-        // their preset/model must not be reported as hot-reloaded successfully.
-        if (externallyOwned) {
-            throw new Error('目标伙伴还有由 DSH 管理的活动会话，请重新打开会话使配置生效');
+    /** Awaited by the host before prompt/tool assembly, never from a running tool. */
+    async prepareAgentTurn(agent, turn, signal) {
+        if (this.closed)
+            throw new Error('伙伴运行时已关闭');
+        if (this.preparedTurns.get(agent) === turn)
+            return;
+        const configuration = this.configurations.forSession(agent.session.id);
+        if (!configuration)
+            return;
+        if (this.store.isCompanionRemoving(configuration.companion.id))
+            throw new Error('伙伴正在删除，不能启动新轮次');
+        signal.throwIfAborted();
+        const installed = this.restoredCompositions.get(agent.session.id);
+        if (installed?.agent !== agent || installed.revision !== configuration.revision) {
+            const profile = await this.memory?.profileSnapshot(configuration.companion.id, memoryScope(configuration.route.channelId, configuration.route.userId)).catch(() => undefined);
+            signal.throwIfAborted();
+            if (this.closed)
+                throw new Error('伙伴运行时已关闭');
+            const job = this.composeRestoredAgent(agent, configuration.companion, configuration.route, configuration.revision, profile, signal);
+            this.restoredCompositionJobs.set(agent.session.id, job);
+            try {
+                await job;
+            }
+            finally {
+                if (this.restoredCompositionJobs.get(agent.session.id) === job)
+                    this.restoredCompositionJobs.delete(agent.session.id);
+            }
         }
+        this.preparedTurns.set(agent, turn);
     }
     isCompanionBusy(companionId) {
-        return this.store.snapshot().sessions.some(route => route.companionId === companionId
+        return this.observationJobs.has(companionId) || this.agentSetupJobs.has(companionId) || this.store.snapshot().sessions.some(route => route.companionId === companionId
             && (this.handles.get(route.sessionId)?.agent ?? this.ctx.agents.get(route.sessionId))?.status === 'running');
     }
     async releaseCompanion(companionId) {
@@ -529,7 +599,10 @@ export class PartnerAgentRuntime {
         await this.store.update(state => { state.sessions = state.sessions.filter(item => item.channelId !== channelId); });
     }
     async close() {
+        this.closed = true;
+        this.disposeConfigurationListener();
         this.disposeAgentListener();
+        this.configurations.close();
         await Promise.allSettled(this.restoredCompositionJobs.values());
         for (const restored of this.restoredCompositions.values())
             restored.dispose();
@@ -545,6 +618,8 @@ export class PartnerAgentRuntime {
     async releaseRestoredComposition(sessionId) {
         await this.restoredCompositionJobs.get(sessionId)?.catch(() => { });
         const restored = this.restoredCompositions.get(sessionId);
+        if (restored)
+            this.preparedTurns.delete(restored.agent);
         restored?.dispose();
         this.restoredCompositions.delete(sessionId);
     }
@@ -575,7 +650,7 @@ export class PartnerAgentRuntime {
             source: { kind: 'user' },
         }));
         await agent.whenIdle();
-        const response = assistantTextAfter(agent, startSeq);
+        const response = channelReplyTextAfter(agent.session.snapshotEvents(), startSeq);
         await this.store.update(state => {
             const target = state.sessions.find(item => item.id === session.id);
             if (target)
@@ -635,6 +710,22 @@ export class PartnerAgentRuntime {
         return session;
     }
     async ensureAgent(companion, route) {
+        if (this.store.isCompanionRemoving(companion.id) || !this.store.snapshot().companions.some(item => item.id === companion.id))
+            throw new Error('伙伴正在删除或已不存在');
+        const id = companion.id;
+        this.agentSetupJobs.set(id, (this.agentSetupJobs.get(id) ?? 0) + 1);
+        try {
+            return await this.ensureAgentReady(companion, route);
+        }
+        finally {
+            const left = (this.agentSetupJobs.get(id) ?? 1) - 1;
+            if (left)
+                this.agentSetupJobs.set(id, left);
+            else
+                this.agentSetupJobs.delete(id);
+        }
+    }
+    async ensureAgentReady(companion, route) {
         const cwd = route.cwd ?? this.defaultCwd;
         await mkdir(cwd, { recursive: true, mode: 0o700 });
         const profile = await this.memory?.profileSnapshot(companion.id, memoryScope(route.channelId, route.userId)).catch(() => undefined);
@@ -647,7 +738,6 @@ export class PartnerAgentRuntime {
         }
         const live = this.ctx.agents.get(route.sessionId);
         if (live !== undefined) {
-            await this.ensureRestoredComposition(live, companion, route, profile);
             await this.attachSession(companion, route);
             if (profile)
                 this.injectProfileUpdate(live, route.sessionId, profile);
@@ -659,24 +749,8 @@ export class PartnerAgentRuntime {
             if (presets === undefined)
                 throw new Error('伙伴会话缺少 Agent Presets 服务');
             await presets.mount(agentCtx, companion.presetId);
-            agentCtx.systemPrompt.section({
-                name: 'partner-identity',
-                order: -10,
-                text: renderPartnerPersona(companion, route.kind === 'local' ? 'local' : 'conversation'),
-            });
-            agentCtx.systemPrompt.section({
-                name: 'partner-tool-routing',
-                order: -9,
-                text: renderToolProtocol(),
-            });
-            if (profile && profile.entries.length > 0)
-                agentCtx.systemPrompt.section({
-                    name: 'partner-user-profile',
-                    order: -8,
-                    text: renderProfile(profile),
-                });
-            this.questionAnswerer?.(agentCtx, route);
-            await this.composer?.compose(agentCtx, companion);
+            // Partner composition is installed at the same awaited pre-step boundary
+            // for factory-created and native browser-resumed Agents alike.
         };
         let handle;
         try {
@@ -703,69 +777,53 @@ export class PartnerAgentRuntime {
         await this.attachSession(companion, route);
         return handle.agent;
     }
-    async ensureRestoredComposition(agent, companion, route, profile) {
-        const installed = this.restoredCompositions.get(route.sessionId);
-        if (installed?.agent === agent)
-            return;
-        const pending = this.restoredCompositionJobs.get(route.sessionId);
-        if (pending !== undefined)
-            return pending;
-        const job = this.composeRestoredAgent(agent, companion, route, profile);
-        this.restoredCompositionJobs.set(route.sessionId, job);
-        try {
-            await job;
-        }
-        finally {
-            if (this.restoredCompositionJobs.get(route.sessionId) === job)
-                this.restoredCompositionJobs.delete(route.sessionId);
+    async composeRestoredAgent(agent, companion, route, revision, profile, signal) {
+        // Already inside the driver's awaited pre-step hook. Waiting for idle or
+        // runMaintenance here would deadlock the very turn we are preparing.
+        signal.throwIfAborted();
+        const agentCtx = agent.ctx;
+        const key = scopeOf(agentCtx);
+        if (key === undefined)
+            throw new Error('伙伴会话缺少 Agent 作用域');
+        if (scopeParentOf(key) === undefined) {
+            const presets = agentCtx.get('agentPresets');
+            if (presets === undefined)
+                throw new Error('伙伴会话缺少 Agent Presets 服务');
+            await presets.mount(agentCtx, companion.presetId);
         }
-    }
-    async composeRestoredAgent(agent, companion, route, profile) {
-        await agent.whenIdle();
-        let dispose;
-        await agent.runMaintenance(async (signal) => {
-            if (signal.aborted)
-                throw signal.reason;
-            const agentCtx = agent.ctx;
-            const key = scopeOf(agentCtx);
-            if (key === undefined)
-                throw new Error('伙伴会话缺少 Agent 作用域');
-            if (scopeParentOf(key) === undefined) {
-                const presets = agentCtx.get('agentPresets');
-                if (presets === undefined)
-                    throw new Error('伙伴会话缺少 Agent Presets 服务');
-                await presets.mount(agentCtx, companion.presetId);
-            }
-            const disposers = [];
-            try {
-                disposers.push(agentCtx.systemPrompt.section({ name: 'partner-identity', order: -10, text: renderPartnerPersona(companion, route.kind === 'local' ? 'local' : 'conversation') }));
-                disposers.push(agentCtx.systemPrompt.section({ name: 'partner-tool-routing', order: -9, text: renderToolProtocol() }));
-                if (profile && profile.entries.length > 0)
-                    disposers.push(agentCtx.systemPrompt.section({ name: 'partner-user-profile', order: -8, text: renderProfile(profile) }));
-                if (this.questionAnswerer)
-                    disposers.push(this.questionAnswerer(agentCtx, route));
-                if (this.composer)
-                    disposers.push(await this.composer.compose(agentCtx, companion));
-            }
-            catch (error) {
-                for (let index = disposers.length - 1; index >= 0; index -= 1)
-                    disposers[index]?.();
-                throw error;
-            }
-            let disposed = false;
-            dispose = () => {
-                if (disposed)
-                    return;
-                disposed = true;
-                for (let index = disposers.length - 1; index >= 0; index -= 1)
-                    disposers[index]?.();
-            };
-        });
-        if (dispose === undefined)
-            throw new Error('伙伴会话恢复组合未完成');
         const previous = this.restoredCompositions.get(route.sessionId);
         previous?.dispose();
-        this.restoredCompositions.set(route.sessionId, { agent, dispose });
+        this.restoredCompositions.delete(route.sessionId);
+        const disposers = [];
+        try {
+            disposers.push(agentCtx.systemPrompt.section({ name: 'partner-identity', order: -10, text: renderPartnerPersona(companion, route.kind === 'local' ? 'local' : 'conversation') }));
+            disposers.push(agentCtx.systemPrompt.section({ name: 'partner-tool-routing', order: -9, text: renderToolProtocol() }));
+            if (profile && profile.entries.length > 0)
+                disposers.push(agentCtx.systemPrompt.section({ name: 'partner-user-profile', order: -8, text: renderProfile(profile) }));
+            if (this.questionAnswerer)
+                disposers.push(this.questionAnswerer(agentCtx, route));
+            if (this.composer)
+                disposers.push(await this.composer.compose(agentCtx, companion));
+            signal.throwIfAborted();
+            if (this.closed)
+                throw new Error('伙伴运行时已关闭');
+        }
+        catch (error) {
+            for (let index = disposers.length - 1; index >= 0; index -= 1)
+                disposers[index]?.();
+            throw error;
+        }
+        let disposed = false;
+        const dispose = () => {
+            if (disposed)
+                return;
+            disposed = true;
+            for (let index = disposers.length - 1; index >= 0; index -= 1)
+                disposers[index]?.();
+        };
+        // Keep the captured revision: a concurrent save must be applied next turn,
+        // never incorrectly recorded as already installed by this composition.
+        this.restoredCompositions.set(route.sessionId, { agent, dispose, revision });
     }
     injectProfileUpdate(agent, sessionId, profile) {
         const previous = this.profileVersions.get(sessionId);