shennian 0.3.84 → 0.3.86

package/dist/src/session/manager.js

@@ -1 +1,658 @@
-import{SESSION_SYNC_PROTOCOL_VERSION as p,SESSION_SYNC_DATA_EPOCH as f,isAvailableAgentType as k}from"@shennian/wire";import g from"node:crypto";import{getRegisteredAgents as S,unregisterAgent as A}from"../agents/adapter.js";import{loadConfig as T}from"../config/index.js";import{handleUpgradeStart as I,handleUpgradeStatus as C}from"../commands/upgrade.js";import{handleAgentsRefresh as P,handleModelsRefresh as E}from"./handlers/agents.js";import{handleAgentCapabilitiesList as D}from"./handlers/agent-capabilities.js";import{handleAgentConfigClear as x,handleAgentConfigGet as M,handleAgentConfigTest as O,handleAgentConfigUpsert as F}from"./handlers/agent-config.js";import{handleChatAbort as _,handleChatSend as v}from"./handlers/chat.js";import{handleSessionRefresh as N}from"./handlers/session-refresh.js";import{handleSessionToolDetail as z}from"./handlers/tool-detail.js";import{handleSessionTitleSet as Q}from"./handlers/title.js";import{handleSessionMessageStatus as U}from"./handlers/message-status.js";import{handleVoiceSessionBodyWindow as W}from"./handlers/voice-window.js";import{handleRemoteAccessPause as V}from"./handlers/remote-access.js";import{cleanupPendingTransfers as B,handleFsLs as j,handleFsRead as $,handleFsRename as L,handleFsWrite as H,handleFsTransferAbort as Y,handleFsTransferChunk as G,handleFsTransferFinish as K,handleFsTransferStart as X,handleFsExportMarkdownPdf as Z,handleFsExportMarkdownPdfSetup as J,handleFsArchiveZip as q}from"./handlers/fs.js";import{handleRegionProbe as ee,handleRegionSwitch as se,handleUpgradeSetPolicy as te}from"./handlers/control.js";import{ManagerRuntimeService as ae,setManagerRuntimeService as b}from"../manager/runtime.js";import{ChatQueueManager as ie}from"./queue.js";import{createAuthorizedFsRoot as ne,createAuthorizedFsRootAsync as oe,resolveAuthorizedPath as re,resolveAuthorizedPathAsync as ce,resolveSessionWorkDir as le}from"../fs/boundary.js";import"../agents/claude.js";import"../agents/codex.js";import"../agents/workbuddy.js";import"../agents/gemini.js";import"../agents/cursor.js";import"../agents/opencode.js";import"../agents/manager.js";import{registerCustomAgent as he}from"../agents/custom.js";import{handleManagedRoomBind as de,handleManagedRoomRestart as ue}from"./handlers/room-managed.js";import{getDaemonInstallationId as y,listSessionRecords as R,purgeCanonicalSession as me,purgeSessionRecord as pe}from"./store.js";import{PersonalHistorySubscriptions as fe}from"./history-subscriptions.js";import{sweepAttachmentTransfers as ge}from"./attachment-transfer-store.js";import{NativeSourceDeletionStore as ve}from"../native-fusion/native-source-deletions.js";import{purgeToolDetails as be}from"./tool-detail-store.js";import{readDeletionSyncRevision as ye,writeDeletionSyncRevision as w}from"./deletion-sync-state.js";import{assertDeletionSyncRunnable as Re,clearDeletionSyncFailure as we,DeletionSyncRetryWaitError as ke,DeletionSyncTerminalError as Se,recordDeletionSyncFailure as m}from"./deletion-sync-state.js";import{NativeSessionCleanupOutbox as Ae}from"./native-cleanup-outbox.js";import{assertPersonalSyncIdentity as l}from"../personal-sync/epoch.js";const Te=50;function Ie(r,e){if(!r||!Number.isSafeInteger(r.baselineRevision)||r.baselineRevision<e||!Number.isSafeInteger(r.latestRevision)||r.latestRevision<r.baselineRevision||!Array.isArray(r.deletions))throw new Error("invalid deletion sync response");let s=r.baselineRevision;for(const t of r.deletions){if(!t?.sessionId||!Number.isSafeInteger(t.deletionRevision)||t.deletionRevision!==s+1||!Array.isArray(t.sources)||Number.isNaN(Date.parse(t.deletedAt))||t.nativeCleanupPolicy!==void 0&&t.nativeCleanupPolicy!=="none"&&t.nativeCleanupPolicy!=="auto")throw new Error("invalid session deletion command");for(const a of t.sources)if(!a?.sourceSessionKey||!k(a.agentType))throw new Error("invalid native source deletion command");s=t.deletionRevision}if(s!==r.latestRevision)throw new Error("invalid deletion sync revision range")}import{resolveSessionWorkDir as ps}from"../fs/boundary.js";class ds{client;nativeFusion;cliVersion;upgradePolicyController;managedRoomBinder;remoteAccessPauseController;managedRoomContextRevoker;managedRoomExecutor;sessions=new Map;processedReqIds=new Set;runTextAcc=new Map;pendingTransfers=new Map;managerRuntime;chatQueue;historySubscriptions;nativeCleanupOutbox;activityProbeTimer=null;attachmentCleanupTimer=null;activeRequests=0;constructor(e,s=null,t,a=null,i=null,c=null,n=null,h=null){this.client=e,this.nativeFusion=s,this.cliVersion=t,this.upgradePolicyController=a,this.managedRoomBinder=i,this.remoteAccessPauseController=c,this.managedRoomContextRevoker=n,this.managedRoomExecutor=h,this.managerRuntime=new ae({getRuntime:()=>this.getRuntime(),dispatchReq:o=>this.handleReq(o)}),this.chatQueue=new ie({getRuntime:()=>this.getRuntime(),dispatchReq:o=>this.handleReq(o),dispatchQueuedReq:o=>this.dispatchQueuedChat(o)}),this.historySubscriptions=new fe(this.client),this.nativeCleanupOutbox=new Ae({logger:console.info}),this.nativeFusion?.setExternalTerminalHandler?.(o=>{this.handleExternalTerminal(o)}),this.nativeCleanupOutbox.start(),b(this.managerRuntime),this.managerRuntime.start(),this.reloadCustomAgents(),this.activityProbeTimer=setInterval(()=>{this.publishManagedActivitySnapshots().catch(o=>{console.error("[session.activity] managed probe failed",o)})},15e3),this.activityProbeTimer.unref?.(),this.attachmentCleanupTimer=setInterval(()=>{const o=new Set([...R().map(d=>d.workDir),...Array.from(this.pendingTransfers.values()).map(d=>d.rootPath)]);for(const d of o)try{ge(this.resolvePath(d))}catch(u){console.error("[attachment.cleanup] failed",u instanceof Error?u.message:String(u))}},6e4),this.attachmentCleanupTimer.unref?.()}getRuntime(){return{client:this.client,pendingTransfers:this.pendingTransfers,processedReqIds:this.processedReqIds,reloadCustomAgents:()=>this.reloadCustomAgents(),resolvePath:e=>this.resolvePath(e),resolveAuthorizedPath:(e,s)=>this.resolveAuthorizedPath(e,s),resolveAuthorizedPathAsync:(e,s)=>this.resolveAuthorizedPathAsync(e,s),runTextAcc:this.runTextAcc,sessions:this.sessions,evictIdleSessions:()=>this.evictIdleSessions(),nativeFusion:this.nativeFusion,managerRuntime:this.managerRuntime,chatQueue:this.chatQueue,activityPublisher:{publish:(e,s)=>this.publishSessionActivity(e,s)},upgradePolicyController:this.upgradePolicyController,revokeManagedRoomContextToken:this.managedRoomContextRevoker,managedRoomExecutor:this.managedRoomExecutor}}getUpgradeIdleState(){const e=[];return[...this.sessions.values()].some(s=>s.currentRunId!==null)&&e.push("active-agent-turn"),this.pendingTransfers.size>0&&e.push("file-transfer"),this.activeRequests>0&&e.push("active-daemon-request"),{idle:e.length===0,reasons:e}}setManagedRoomTurnPreparer(e){this.chatQueue.setManagedRoomTurnPreparer(e)}async enqueueManagedRoomBatch(e){const s=e.map(t=>{const a=R().find(i=>i.sessionId===t.params.sessionId);return{context:t.context,params:{...t.params,modelId:a?.modelId??t.params.modelId,sessionMode:a?.sessionMode??t.params.sessionMode,managerConfig:a?.managerConfig??t.params.managerConfig,managerDefaultWorkerAgentType:a?.managerDefaultWorkerAgentType??t.params.managerDefaultWorkerAgentType,managerDefaultWorkerModelId:a?.managerDefaultWorkerModelId??t.params.managerDefaultWorkerModelId}}});await this.chatQueue.enqueueManagedRoomBatch(s)}async dispatchQueuedChat(e){const s={value:null},t=new Proxy(this.client,{get:(c,n)=>{if(n==="sendRes")return o=>{s.value=o};const h=Reflect.get(c,n,c);return typeof h=="function"?h.bind(c):h}}),a=e.params,i=a.roomActivation===!0?{source:"room_activation",managedAgentPolicy:a.managedAgentPolicy,managedRoomPromptSnapshot:a.managedRoomPromptSnapshot}:void 0;if(await v({...this.getRuntime(),client:t},e,i),!s.value?.ok||s.value.payload?.deliveryState==="failed")throw new Error(s.value?.error??"queued_chat_dispatch_failed")}async synchronizeSessionDeletions(){Re();try{await this.synchronizeSessionDeletionsOnce(),we()}catch(e){if(e instanceof ke||e instanceof Se)throw e;const s=e instanceof Error?e.message:String(e),t=/offline|not connected|disconnect|timed out|timeout|temporar|unavailable|ECONN|ENOTFOUND|EIO|EBUSY/i.test(s);throw m({code:t?"transport_unavailable":"invalid_deletion_sync_response",retryable:t}),e}}async synchronizeSessionDeletionsOnce(){const e=y(),s=ye(),t=await this.client.sendReq({type:"req",id:`session-deletions-sync-${g.randomUUID()}`,method:"session.deletions.sync",params:{protocolVersion:p,dataEpoch:f,daemonInstallationId:e,afterRevision:s}});if(!t.ok){const n=t.rejection;throw n?(m({code:n.code,retryable:n.retryable&&n.requiredAction==="retry"}),new Error(n.code)):(m({code:"unstructured_rejection",retryable:!1}),new Error(t.error??"unstructured_rejection"))}const a=t.payload;l(a),Ie(a,s);let i=a.baselineRevision;i>s&&w(i);for(const n of a.deletions)n.deletionRevision<=i||(await this.applySessionDeletion(n),i=n.deletionRevision,w(i));if(i!==a.latestRevision)throw new Error(`deletion revision gap: applied ${i}, latest ${a.latestRevision}`);if(i===0)return;const c=await this.client.sendReq({type:"req",id:`session-deletions-ack-${g.randomUUID()}`,method:"session.deletions.ack",params:{protocolVersion:p,dataEpoch:f,daemonInstallationId:e,deletionRevision:i}});if(!c.ok)throw new Error(c.error??"session deletion acknowledgement failed")}async applySessionDeletion(e){const s=new ve({daemonInstallationId:y()});s.recordSession(e);for(const a of e.sources)s.record({...e,...a});const t=this.sessions.get(e.sessionId);if(t){this.revokeManagedRoomToken(t);try{await t.adapter.stop()}catch{}this.sessions.delete(e.sessionId)}this.historySubscriptions.closeSession(e.sessionId),this.nativeFusion?.handleSessionDeleted(e.sessionId),this.chatQueue.purgeSession(e.sessionId),be(e.sessionId),me(e.sessionId),pe(e.sessionId),this.runTextAcc.delete(e.sessionId),this.publishSessionActivity(e.sessionId,null),this.nativeCleanupOutbox.enqueue(e),this.nativeCleanupOutbox.kick()}publishSessionActivity(e,s){this.client.sendEvent({type:"event",event:"session.activity",payload:{sessionId:e,activity:s}})}async handleExternalTerminal(e){const s=this.sessions.get(e);s&&(this.sessions.delete(e),this.revokeManagedRoomToken(s),s.heartbeatTimer&&clearInterval(s.heartbeatTimer),s.adapter.removeAllListeners(),await s.adapter.stop().catch(()=>{})),this.chatQueue.noteTerminal(e)}async publishManagedActivitySnapshots(){for(const[e,s]of this.sessions.entries()){if(s.heartbeatTimer||!s.currentRunId||!s.adapter.getStatus)continue;const t=await s.adapter.getStatus().catch(()=>null);if(!t?.active||!t.runPhase)continue;const a=new Date().toISOString();this.publishSessionActivity(e,{sessionId:e,runId:t.runId||s.currentRunId,runPhase:t.runPhase,startedAt:new Date(s.lastActiveAt).toISOString(),updatedAt:a,canStop:t.canStop??!0});const i=s.heartbeatSeq++;this.client.sendAgentEvent({type:"event",event:"agent",payload:{state:"heartbeat",sessionId:e,runId:t.runId||s.currentRunId,seq:i,runPhase:t.runPhase,canStop:t.canStop??!0},seq:i,id:`agent-status-${t.runId||s.currentRunId}-${Date.now()}`})}}reloadCustomAgents(){for(const s of S())s.startsWith("custom:")&&A(s);const e=T();for(const[s,t]of Object.entries(e.customAgents??{}))he(s,t)}async handleReq(e){const s=this.getRuntime();this.activeRequests++;try{switch(e.method){case"chat.send":l(e.params),await v(s,e);break;case"chat.enqueue":l(e.params),await this.chatQueue.handleEnqueue(e);break;case"chat.queue.get":l(e.params),await this.chatQueue.handleGet(e);break;case"chat.queue.edit":l(e.params),await this.chatQueue.handleEdit(e);break;case"chat.queue.delete":l(e.params),await this.chatQueue.handleDelete(e);break;case"chat.abort":l(e.params),await _(s,e);break;case"session.refresh":l(e.params),await N(s,e);break;case"session.history.open":this.historySubscriptions.handleOpen(e);break;case"session.history.sync":this.historySubscriptions.handleSync(e);break;case"session.history.page":this.historySubscriptions.handlePage(e);break;case"session.history.close":this.historySubscriptions.handleClose(e);break;case"session.body.replica.subscribe":this.historySubscriptions.handleReplicaSubscribe(e);break;case"session.body.replica.unsubscribe":this.historySubscriptions.handleReplicaUnsubscribe(e);break;case"session.history":this.client.sendRes({type:"res",id:e.id,ok:!1,error:"upgrade_required"});break;case"session.message.status":U(s,e);break;case"session.tool.detail":await z(s,e);break;case"voice.session.body.window":W(s,e);break;case"session.title.set":await Q(s,e);break;case"room.agent.bind-managed":await de(s,this.managedRoomBinder,e);break;case"room.agent.restart-managed":await ue(s,this.managedRoomBinder,e);break;case"fs.ls":await j(s,e);break;case"fs.read":await $(s,e);break;case"fs.write":await H(s,e);break;case"fs.export.markdown-pdf":await Z(s,e);break;case"fs.export.markdown-pdf.setup":await J(s,e);break;case"fs.archive.zip":await q(s,e);break;case"fs.rename":await L(s,e);break;case"fs.transfer.start":await X(s,e);break;case"fs.transfer.chunk":await G(s,e);break;case"fs.transfer.finish":await K(s,e);break;case"fs.transfer.abort":await Y(s,e);break;case"region.probe":await ee(s,e);break;case"region.switch":await se(s,e);break;case"upgrade.start":await I(this.client,e.id,e.params.version,{currentVersion:this.cliVersion,confirmedMajor:e.params.confirmedMajor===!0});break;case"upgrade.status":await C(this.client,e.id,{currentVersion:this.cliVersion});break;case"upgrade.set-policy":await te(s,e);break;case"machine.remote-access.pause":await V(this.client,this.remoteAccessPauseController,e);break;case"agents.refresh":await P(s,e);break;case"models.refresh":await E(s,e);break;case"agent.config.get":await M(s,e);break;case"agent.config.upsert":await F(s,e);break;case"agent.config.clear":await x(s,e);break;case"agent.config.test":await O(s,e);break;case"agent.capabilities.list":await D(s,e);break;case"skill.list":case"skill.install":case"skill.doctor":case"skill.setup":case"skill.use":this.client.sendRes({type:"res",id:e.id,ok:!1,error:"feature_retired"});break;case"session.wechat-rpa.channel.get":case"session.wechat-rpa.channel.upsert":case"session.wechat-rpa.channel.sync":case"manager.wechat-rpa.channel.get":case"manager.wechat-rpa.channel.upsert":case"manager.wechat-rpa.channel.sync":this.client.sendRes({type:"res",id:e.id,ok:!1,error:"feature_retired"});break;default:this.client.sendRes({type:"res",id:e.id,ok:!1,error:`Unknown method: ${e.method}`})}}catch(t){this.client.sendRes({type:"res",id:e.id,ok:!1,error:t instanceof Error?t.message:String(t)})}finally{this.activeRequests--}}evictIdleSessions(){if(this.sessions.size<Te)return;let e=null;for(const[s,t]of this.sessions)(!e||t.lastActiveAt<e.session.lastActiveAt)&&(e={key:s,session:t});e&&(this.revokeManagedRoomToken(e.session),e.session.heartbeatTimer&&(clearInterval(e.session.heartbeatTimer),e.session.heartbeatTimer=null),e.session.adapter.removeAllListeners(),e.session.adapter.stop().catch(()=>{}),this.sessions.delete(e.key))}resolvePath(e){return le(e)}resolveAuthorizedPath(e,s){return re(e,ne(s))}async resolveAuthorizedPathAsync(e,s){return ce(e,await oe(s))}async cleanup(){this.nativeFusion?.setExternalTerminalHandler?.(null),this.nativeCleanupOutbox.stop(),this.historySubscriptions.closeAll(),this.activityProbeTimer&&(clearInterval(this.activityProbeTimer),this.activityProbeTimer=null),this.attachmentCleanupTimer&&(clearInterval(this.attachmentCleanupTimer),this.attachmentCleanupTimer=null);for(const[,e]of this.sessions)this.revokeManagedRoomToken(e),e.heartbeatTimer&&(clearInterval(e.heartbeatTimer),e.heartbeatTimer=null),await e.adapter.stop().catch(()=>{});this.sessions.clear(),this.runTextAcc.clear(),B(this.getRuntime()),await this.managerRuntime.stop(),b(null)}revokeManagedRoomToken(e){const s=e.managedRoomContextToken;e.managedRoomContextToken=null,s&&this.managedRoomContextRevoker?.(s)}}export{ds as SessionManager,ps as resolveSessionWorkDir};
+// @arch docs/architecture/cli/daemon.md#会话管理
+// @test src/__tests__/session-store.test.ts
+// @test src/__tests__/model-switching.test.ts
+import { SESSION_SYNC_PROTOCOL_VERSION, SESSION_SYNC_DATA_EPOCH, isAvailableAgentType, } from '@shennian/wire';
+import crypto from 'node:crypto';
+import { getRegisteredAgents, unregisterAgent } from '../agents/adapter.js';
+import { loadConfig } from '../config/index.js';
+import { handleUpgradeStart, handleUpgradeStatus } from '../commands/upgrade.js';
+import { handleAgentsRefresh, handleModelsRefresh } from './handlers/agents.js';
+import { handleAgentCapabilitiesList } from './handlers/agent-capabilities.js';
+import { handleAgentConfigClear, handleAgentConfigGet, handleAgentConfigTest, handleAgentConfigUpsert, } from './handlers/agent-config.js';
+import { handleChatAbort, handleChatSend } from './handlers/chat.js';
+import { handleSessionRefresh } from './handlers/session-refresh.js';
+import { handleSessionToolDetail } from './handlers/tool-detail.js';
+import { handleSessionTitleSet } from './handlers/title.js';
+import { handleSessionMessageStatus } from './handlers/message-status.js';
+import { handleVoiceSessionBodyWindow } from './handlers/voice-window.js';
+import { handleRemoteAccessPause } from './handlers/remote-access.js';
+import { cleanupPendingTransfers, handleFsLs, handleFsRead, handleFsRename, handleFsWrite, handleFsTransferAbort, handleFsTransferChunk, handleFsTransferFinish, handleFsTransferStart, handleFsExportMarkdownPdf, handleFsExportMarkdownPdfSetup, handleFsArchiveZip, } from './handlers/fs.js';
+import { handleRegionProbe, handleRegionSwitch, handleUpgradeSetPolicy, } from './handlers/control.js';
+import { ManagerRuntimeService, setManagerRuntimeService } from '../manager/runtime.js';
+import { ChatQueueManager, TerminalQueuedChatDispatchError, } from './queue.js';
+import { createAuthorizedFsRoot, createAuthorizedFsRootAsync, resolveAuthorizedPath, resolveAuthorizedPathAsync, resolveSessionWorkDir, } from '../fs/boundary.js';
+// Side-effect imports to register built-in agent adapters.
+import '../agents/claude.js';
+import '../agents/codex.js';
+import '../agents/workbuddy.js';
+import '../agents/gemini.js';
+import '../agents/cursor.js';
+// OpenClaw support is intentionally disabled.
+// import '../agents/openclaw.js'
+import '../agents/opencode.js';
+import '../agents/manager.js';
+import { registerCustomAgent } from '../agents/custom.js';
+import { handleManagedRoomBind, handleManagedRoomRestart } from './handlers/room-managed.js';
+import { getDaemonInstallationId, listSessionRecords, purgeCanonicalSession, purgeSessionRecord, } from './store.js';
+import { PersonalHistorySubscriptions } from './history-subscriptions.js';
+import { sweepAttachmentTransfers } from './attachment-transfer-store.js';
+import { NativeSourceDeletionStore } from '../native-fusion/native-source-deletions.js';
+import { purgeToolDetails } from './tool-detail-store.js';
+import { readDeletionSyncRevision, writeDeletionSyncRevision } from './deletion-sync-state.js';
+import { assertDeletionSyncRunnable, clearDeletionSyncFailure, DeletionSyncRetryWaitError, DeletionSyncTerminalError, recordDeletionSyncFailure, } from './deletion-sync-state.js';
+import { NativeSessionCleanupOutbox } from './native-cleanup-outbox.js';
+import { assertPersonalSyncIdentity } from '../personal-sync/epoch.js';
+const MAX_SESSIONS = 50;
+function validateDeletionSyncResponse(payload, afterRevision) {
+    if (!payload ||
+        !Number.isSafeInteger(payload.baselineRevision) ||
+        payload.baselineRevision < afterRevision ||
+        !Number.isSafeInteger(payload.latestRevision) ||
+        payload.latestRevision < payload.baselineRevision ||
+        !Array.isArray(payload.deletions))
+        throw new Error('invalid deletion sync response');
+    let previous = payload.baselineRevision;
+    for (const deletion of payload.deletions) {
+        if (!deletion?.sessionId ||
+            !Number.isSafeInteger(deletion.deletionRevision) ||
+            deletion.deletionRevision !== previous + 1 ||
+            !Array.isArray(deletion.sources) ||
+            Number.isNaN(Date.parse(deletion.deletedAt)) ||
+            (deletion.nativeCleanupPolicy !== undefined &&
+                deletion.nativeCleanupPolicy !== 'none' &&
+                deletion.nativeCleanupPolicy !== 'auto')) {
+            throw new Error('invalid session deletion command');
+        }
+        for (const source of deletion.sources) {
+            if (!source?.sourceSessionKey || !isAvailableAgentType(source.agentType)) {
+                throw new Error('invalid native source deletion command');
+            }
+        }
+        previous = deletion.deletionRevision;
+    }
+    if (previous !== payload.latestRevision)
+        throw new Error('invalid deletion sync revision range');
+}
+export { resolveSessionWorkDir } from '../fs/boundary.js';
+export class SessionManager {
+    client;
+    nativeFusion;
+    cliVersion;
+    upgradePolicyController;
+    managedRoomBinder;
+    remoteAccessPauseController;
+    managedRoomContextRevoker;
+    managedRoomExecutor;
+    sessions = new Map();
+    /** Track processed request IDs to deduplicate replayed offline messages */
+    processedReqIds = new Set();
+    /** Accumulate agent text per run for messageSummary on final event */
+    runTextAcc = new Map();
+    /** In-flight chunked uploads: transferId → metadata */
+    pendingTransfers = new Map();
+    managerRuntime;
+    chatQueue;
+    historySubscriptions;
+    nativeCleanupOutbox;
+    activityProbeTimer = null;
+    attachmentCleanupTimer = null;
+    activeRequests = 0;
+    constructor(client, nativeFusion = null, cliVersion, upgradePolicyController = null, managedRoomBinder = null, remoteAccessPauseController = null, managedRoomContextRevoker = null, managedRoomExecutor = null) {
+        this.client = client;
+        this.nativeFusion = nativeFusion;
+        this.cliVersion = cliVersion;
+        this.upgradePolicyController = upgradePolicyController;
+        this.managedRoomBinder = managedRoomBinder;
+        this.remoteAccessPauseController = remoteAccessPauseController;
+        this.managedRoomContextRevoker = managedRoomContextRevoker;
+        this.managedRoomExecutor = managedRoomExecutor;
+        this.managerRuntime = new ManagerRuntimeService({
+            getRuntime: () => this.getRuntime(),
+            dispatchReq: (req) => this.handleReq(req),
+        });
+        this.chatQueue = new ChatQueueManager({
+            getRuntime: () => this.getRuntime(),
+            dispatchReq: (req) => this.handleReq(req),
+            dispatchQueuedReq: (req) => this.dispatchQueuedChat(req),
+        });
+        this.historySubscriptions = new PersonalHistorySubscriptions(this.client);
+        this.nativeCleanupOutbox = new NativeSessionCleanupOutbox({ logger: console.info });
+        this.nativeFusion?.setExternalTerminalHandler?.((sessionId) => {
+            void this.handleExternalTerminal(sessionId);
+        });
+        this.nativeCleanupOutbox.start();
+        setManagerRuntimeService(this.managerRuntime);
+        void this.managerRuntime.start();
+        this.reloadCustomAgents();
+        this.activityProbeTimer = setInterval(() => {
+            void this.publishManagedActivitySnapshots().catch((error) => {
+                console.error('[session.activity] managed probe failed', error);
+            });
+        }, 15_000);
+        this.activityProbeTimer.unref?.();
+        this.attachmentCleanupTimer = setInterval(() => {
+            const workDirs = new Set([
+                ...listSessionRecords().map((record) => record.workDir),
+                ...Array.from(this.pendingTransfers.values()).map((transfer) => transfer.rootPath),
+            ]);
+            for (const workDir of workDirs) {
+                try {
+                    sweepAttachmentTransfers(this.resolvePath(workDir));
+                }
+                catch (error) {
+                    console.error('[attachment.cleanup] failed', error instanceof Error ? error.message : String(error));
+                }
+            }
+        }, 60_000);
+        this.attachmentCleanupTimer.unref?.();
+    }
+    getRuntime() {
+        return {
+            client: this.client,
+            pendingTransfers: this.pendingTransfers,
+            processedReqIds: this.processedReqIds,
+            reloadCustomAgents: () => this.reloadCustomAgents(),
+            resolvePath: (pathValue) => this.resolvePath(pathValue),
+            resolveAuthorizedPath: (pathValue, rootPath) => this.resolveAuthorizedPath(pathValue, rootPath),
+            resolveAuthorizedPathAsync: (pathValue, rootPath) => this.resolveAuthorizedPathAsync(pathValue, rootPath),
+            runTextAcc: this.runTextAcc,
+            sessions: this.sessions,
+            evictIdleSessions: () => this.evictIdleSessions(),
+            nativeFusion: this.nativeFusion,
+            managerRuntime: this.managerRuntime,
+            chatQueue: this.chatQueue,
+            activityPublisher: {
+                publish: (sessionId, activity) => this.publishSessionActivity(sessionId, activity),
+            },
+            upgradePolicyController: this.upgradePolicyController,
+            revokeManagedRoomContextToken: this.managedRoomContextRevoker,
+            managedRoomExecutor: this.managedRoomExecutor,
+        };
+    }
+    getUpgradeIdleState() {
+        const reasons = [];
+        if ([...this.sessions.values()].some((session) => session.currentRunId !== null)) {
+            reasons.push('active-agent-turn');
+        }
+        if (this.pendingTransfers.size > 0)
+            reasons.push('file-transfer');
+        if (this.activeRequests > 0)
+            reasons.push('active-daemon-request');
+        return { idle: reasons.length === 0, reasons };
+    }
+    setManagedRoomTurnPreparer(prepare) {
+        this.chatQueue.setManagedRoomTurnPreparer(prepare);
+    }
+    async enqueueManagedRoomBatch(inputs) {
+        const enriched = inputs.map((input) => {
+            const persisted = listSessionRecords().find((record) => record.sessionId === input.params.sessionId);
+            return {
+                context: input.context,
+                params: {
+                    ...input.params,
+                    modelId: persisted?.modelId ?? input.params.modelId,
+                    sessionMode: persisted?.sessionMode ?? input.params.sessionMode,
+                    managerConfig: persisted?.managerConfig ?? input.params.managerConfig,
+                    managerDefaultWorkerAgentType: persisted?.managerDefaultWorkerAgentType ?? input.params.managerDefaultWorkerAgentType,
+                    managerDefaultWorkerModelId: persisted?.managerDefaultWorkerModelId ?? input.params.managerDefaultWorkerModelId,
+                },
+            };
+        });
+        await this.chatQueue.enqueueManagedRoomBatch(enriched);
+    }
+    async dispatchQueuedChat(req) {
+        const captured = { value: null };
+        const localClient = new Proxy(this.client, {
+            get: (target, property) => {
+                if (property === 'sendRes') {
+                    return (value) => {
+                        captured.value = value;
+                    };
+                }
+                const value = Reflect.get(target, property, target);
+                return typeof value === 'function' ? value.bind(target) : value;
+            },
+        });
+        const params = req.params;
+        const roomContext = params.roomActivation === true
+            ? {
+                source: 'room_activation',
+                managedAgentPolicy: params.managedAgentPolicy,
+                managedRoomPromptSnapshot: params.managedRoomPromptSnapshot,
+            }
+            : undefined;
+        await handleChatSend({ ...this.getRuntime(), client: localClient }, req, roomContext);
+        if (captured.value?.payload?.deliveryState === 'failed') {
+            throw new TerminalQueuedChatDispatchError(captured.value.payload.failureMessage ?? captured.value.error ?? 'queued_chat_dispatch_failed');
+        }
+        if (!captured.value?.ok)
+            throw new Error(captured.value?.error ?? 'queued_chat_dispatch_failed');
+    }
+    async synchronizeSessionDeletions() {
+        assertDeletionSyncRunnable();
+        try {
+            await this.synchronizeSessionDeletionsOnce();
+            clearDeletionSyncFailure();
+        }
+        catch (error) {
+            if (error instanceof DeletionSyncRetryWaitError ||
+                error instanceof DeletionSyncTerminalError) {
+                throw error;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            const retryable = /offline|not connected|disconnect|timed out|timeout|temporar|unavailable|ECONN|ENOTFOUND|EIO|EBUSY/i.test(message);
+            recordDeletionSyncFailure({
+                code: retryable ? 'transport_unavailable' : 'invalid_deletion_sync_response',
+                retryable,
+            });
+            // recordDeletionSyncFailure always throws after persisting in production;
+            // retaining the original error also keeps injected test stores honest.
+            throw error;
+        }
+    }
+    async synchronizeSessionDeletionsOnce() {
+        const daemonInstallationId = getDaemonInstallationId();
+        const afterRevision = readDeletionSyncRevision();
+        const response = await this.client.sendReq({
+            type: 'req',
+            id: `session-deletions-sync-${crypto.randomUUID()}`,
+            method: 'session.deletions.sync',
+            params: {
+                protocolVersion: SESSION_SYNC_PROTOCOL_VERSION,
+                dataEpoch: SESSION_SYNC_DATA_EPOCH,
+                daemonInstallationId,
+                afterRevision,
+            },
+        });
+        if (!response.ok) {
+            const rejection = response.rejection;
+            if (rejection) {
+                recordDeletionSyncFailure({
+                    code: rejection.code,
+                    retryable: rejection.retryable && rejection.requiredAction === 'retry',
+                });
+                throw new Error(rejection.code);
+            }
+            recordDeletionSyncFailure({ code: 'unstructured_rejection', retryable: false });
+            throw new Error(response.error ?? 'unstructured_rejection');
+        }
+        const payload = response.payload;
+        assertPersonalSyncIdentity(payload);
+        validateDeletionSyncResponse(payload, afterRevision);
+        let appliedRevision = payload.baselineRevision;
+        if (appliedRevision > afterRevision)
+            writeDeletionSyncRevision(appliedRevision);
+        for (const deletion of payload.deletions) {
+            if (deletion.deletionRevision <= appliedRevision)
+                continue;
+            await this.applySessionDeletion(deletion);
+            appliedRevision = deletion.deletionRevision;
+            writeDeletionSyncRevision(appliedRevision);
+        }
+        if (appliedRevision !== payload.latestRevision) {
+            throw new Error(`deletion revision gap: applied ${appliedRevision}, latest ${payload.latestRevision}`);
+        }
+        if (appliedRevision === 0)
+            return;
+        const ack = await this.client.sendReq({
+            type: 'req',
+            id: `session-deletions-ack-${crypto.randomUUID()}`,
+            method: 'session.deletions.ack',
+            params: {
+                protocolVersion: SESSION_SYNC_PROTOCOL_VERSION,
+                dataEpoch: SESSION_SYNC_DATA_EPOCH,
+                daemonInstallationId,
+                deletionRevision: appliedRevision,
+            },
+        });
+        if (!ack.ok)
+            throw new Error(ack.error ?? 'session deletion acknowledgement failed');
+    }
+    async applySessionDeletion(deletion) {
+        const tombstones = new NativeSourceDeletionStore({
+            daemonInstallationId: getDaemonInstallationId(),
+        });
+        // The session barrier is the first durable local mutation. If the process
+        // crashes after this point, every body/index writer rejects the session.
+        tombstones.recordSession(deletion);
+        for (const source of deletion.sources)
+            tombstones.record({ ...deletion, ...source });
+        const active = this.sessions.get(deletion.sessionId);
+        if (active) {
+            this.revokeManagedRoomToken(active);
+            try {
+                await active.adapter.stop();
+            }
+            catch { }
+            this.sessions.delete(deletion.sessionId);
+        }
+        this.historySubscriptions.closeSession(deletion.sessionId);
+        this.nativeFusion?.handleSessionDeleted(deletion.sessionId);
+        this.chatQueue.purgeSession(deletion.sessionId);
+        purgeToolDetails(deletion.sessionId);
+        purgeCanonicalSession(deletion.sessionId);
+        purgeSessionRecord(deletion.sessionId);
+        this.runTextAcc.delete(deletion.sessionId);
+        this.publishSessionActivity(deletion.sessionId, null);
+        // enqueue() is a synchronous durable commit. Third-party work begins only
+        // after the deletion command can safely advance and ACK its revision.
+        this.nativeCleanupOutbox.enqueue(deletion);
+        this.nativeCleanupOutbox.kick();
+    }
+    publishSessionActivity(sessionId, activity) {
+        this.client.sendEvent({
+            type: 'event',
+            event: 'session.activity',
+            payload: { sessionId, activity },
+        });
+    }
+    async handleExternalTerminal(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            // An external-owner turn can terminate without emitting through this
+            // adapter instance. Dispose its cached app-server state (including a
+            // stale activeTurnId) before the queued turn creates a fresh adapter.
+            this.sessions.delete(sessionId);
+            this.revokeManagedRoomToken(session);
+            if (session.heartbeatTimer)
+                clearInterval(session.heartbeatTimer);
+            session.adapter.removeAllListeners();
+            await session.adapter.stop().catch(() => { });
+        }
+        this.chatQueue.noteTerminal(sessionId);
+    }
+    async publishManagedActivitySnapshots() {
+        for (const [sessionId, session] of this.sessions.entries()) {
+            // Event-driven sessions already publish a low-cost heartbeat from the
+            // adapter binding. Do not also probe getStatus every 15 seconds.
+            if (session.heartbeatTimer)
+                continue;
+            if (!session.currentRunId || !session.adapter.getStatus)
+                continue;
+            const status = await session.adapter.getStatus().catch(() => null);
+            if (!status?.active || !status.runPhase)
+                continue;
+            const nowIso = new Date().toISOString();
+            this.publishSessionActivity(sessionId, {
+                sessionId,
+                runId: status.runId || session.currentRunId,
+                runPhase: status.runPhase,
+                startedAt: new Date(session.lastActiveAt).toISOString(),
+                updatedAt: nowIso,
+                canStop: status.canStop ?? true,
+            });
+            const seq = session.heartbeatSeq++;
+            this.client.sendAgentEvent({
+                type: 'event',
+                event: 'agent',
+                payload: {
+                    state: 'heartbeat',
+                    sessionId,
+                    runId: status.runId || session.currentRunId,
+                    seq,
+                    runPhase: status.runPhase,
+                    canStop: status.canStop ?? true,
+                },
+                seq,
+                id: `agent-status-${status.runId || session.currentRunId}-${Date.now()}`,
+            });
+        }
+    }
+    reloadCustomAgents() {
+        for (const agentType of getRegisteredAgents()) {
+            if (agentType.startsWith('custom:')) {
+                unregisterAgent(agentType);
+            }
+        }
+        const config = loadConfig();
+        for (const [name, entry] of Object.entries(config.customAgents ?? {})) {
+            registerCustomAgent(name, entry);
+        }
+    }
+    async handleReq(req) {
+        const runtime = this.getRuntime();
+        this.activeRequests++;
+        try {
+            switch (req.method) {
+                case 'chat.send':
+                    assertPersonalSyncIdentity(req.params);
+                    await handleChatSend(runtime, req);
+                    break;
+                case 'chat.enqueue':
+                    assertPersonalSyncIdentity(req.params);
+                    await this.chatQueue.handleEnqueue(req);
+                    break;
+                case 'chat.queue.get':
+                    assertPersonalSyncIdentity(req.params);
+                    await this.chatQueue.handleGet(req);
+                    break;
+                case 'chat.queue.edit':
+                    assertPersonalSyncIdentity(req.params);
+                    await this.chatQueue.handleEdit(req);
+                    break;
+                case 'chat.queue.delete':
+                    assertPersonalSyncIdentity(req.params);
+                    await this.chatQueue.handleDelete(req);
+                    break;
+                case 'chat.abort':
+                    assertPersonalSyncIdentity(req.params);
+                    await handleChatAbort(runtime, req);
+                    break;
+                case 'session.refresh':
+                    assertPersonalSyncIdentity(req.params);
+                    await handleSessionRefresh(runtime, req);
+                    break;
+                case 'session.history.open':
+                    this.historySubscriptions.handleOpen(req);
+                    break;
+                case 'session.history.sync':
+                    this.historySubscriptions.handleSync(req);
+                    break;
+                case 'session.history.page':
+                    this.historySubscriptions.handlePage(req);
+                    break;
+                case 'session.history.close':
+                    this.historySubscriptions.handleClose(req);
+                    break;
+                case 'session.body.replica.subscribe':
+                    this.historySubscriptions.handleReplicaSubscribe(req);
+                    break;
+                case 'session.body.replica.unsubscribe':
+                    this.historySubscriptions.handleReplicaUnsubscribe(req);
+                    break;
+                case 'session.history':
+                    this.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'upgrade_required' });
+                    break;
+                case 'session.message.status':
+                    handleSessionMessageStatus(runtime, req);
+                    break;
+                case 'session.tool.detail':
+                    await handleSessionToolDetail(runtime, req);
+                    break;
+                case 'voice.session.body.window':
+                    handleVoiceSessionBodyWindow(runtime, req);
+                    break;
+                case 'session.title.set':
+                    await handleSessionTitleSet(runtime, req);
+                    break;
+                case 'room.agent.bind-managed':
+                    await handleManagedRoomBind(runtime, this.managedRoomBinder, req);
+                    break;
+                case 'room.agent.restart-managed':
+                    await handleManagedRoomRestart(runtime, this.managedRoomBinder, req);
+                    break;
+                case 'fs.ls':
+                    await handleFsLs(runtime, req);
+                    break;
+                case 'fs.read':
+                    await handleFsRead(runtime, req);
+                    break;
+                case 'fs.write':
+                    await handleFsWrite(runtime, req);
+                    break;
+                case 'fs.export.markdown-pdf':
+                    await handleFsExportMarkdownPdf(runtime, req);
+                    break;
+                case 'fs.export.markdown-pdf.setup':
+                    await handleFsExportMarkdownPdfSetup(runtime, req);
+                    break;
+                case 'fs.archive.zip':
+                    await handleFsArchiveZip(runtime, req);
+                    break;
+                case 'fs.rename':
+                    await handleFsRename(runtime, req);
+                    break;
+                case 'fs.transfer.start':
+                    await handleFsTransferStart(runtime, req);
+                    break;
+                case 'fs.transfer.chunk':
+                    await handleFsTransferChunk(runtime, req);
+                    break;
+                case 'fs.transfer.finish':
+                    await handleFsTransferFinish(runtime, req);
+                    break;
+                case 'fs.transfer.abort':
+                    await handleFsTransferAbort(runtime, req);
+                    break;
+                case 'region.probe':
+                    await handleRegionProbe(runtime, req);
+                    break;
+                case 'region.switch':
+                    await handleRegionSwitch(runtime, req);
+                    break;
+                case 'upgrade.start':
+                    await handleUpgradeStart(this.client, req.id, req.params.version, {
+                        currentVersion: this.cliVersion,
+                        confirmedMajor: req.params.confirmedMajor === true,
+                    });
+                    break;
+                case 'upgrade.status':
+                    await handleUpgradeStatus(this.client, req.id, { currentVersion: this.cliVersion });
+                    break;
+                case 'upgrade.set-policy':
+                    await handleUpgradeSetPolicy(runtime, req);
+                    break;
+                case 'machine.remote-access.pause':
+                    await handleRemoteAccessPause(this.client, this.remoteAccessPauseController, req);
+                    break;
+                case 'agents.refresh':
+                    await handleAgentsRefresh(runtime, req);
+                    break;
+                case 'models.refresh':
+                    await handleModelsRefresh(runtime, req);
+                    break;
+                case 'agent.config.get':
+                    await handleAgentConfigGet(runtime, req);
+                    break;
+                case 'agent.config.upsert':
+                    await handleAgentConfigUpsert(runtime, req);
+                    break;
+                case 'agent.config.clear':
+                    await handleAgentConfigClear(runtime, req);
+                    break;
+                case 'agent.config.test':
+                    await handleAgentConfigTest(runtime, req);
+                    break;
+                case 'agent.capabilities.list':
+                    await handleAgentCapabilitiesList(runtime, req);
+                    break;
+                case 'skill.list':
+                case 'skill.install':
+                case 'skill.doctor':
+                case 'skill.setup':
+                case 'skill.use':
+                    this.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'feature_retired' });
+                    break;
+                case 'session.wechat-rpa.channel.get':
+                case 'session.wechat-rpa.channel.upsert':
+                case 'session.wechat-rpa.channel.sync':
+                case 'manager.wechat-rpa.channel.get':
+                case 'manager.wechat-rpa.channel.upsert':
+                case 'manager.wechat-rpa.channel.sync':
+                    this.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'feature_retired' });
+                    break;
+                default:
+                    this.client.sendRes({
+                        type: 'res',
+                        id: req.id,
+                        ok: false,
+                        error: `Unknown method: ${req.method}`,
+                    });
+            }
+        }
+        catch (err) {
+            this.client.sendRes({
+                type: 'res',
+                id: req.id,
+                ok: false,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        finally {
+            this.activeRequests--;
+        }
+    }
+    // ─── Session eviction ──────────────────────────────────────────────────────
+    evictIdleSessions() {
+        if (this.sessions.size < MAX_SESSIONS)
+            return;
+        let oldest = null;
+        for (const [key, session] of this.sessions) {
+            if (!oldest || session.lastActiveAt < oldest.session.lastActiveAt) {
+                oldest = { key, session };
+            }
+        }
+        if (oldest) {
+            this.revokeManagedRoomToken(oldest.session);
+            if (oldest.session.heartbeatTimer) {
+                clearInterval(oldest.session.heartbeatTimer);
+                oldest.session.heartbeatTimer = null;
+            }
+            oldest.session.adapter.removeAllListeners();
+            oldest.session.adapter.stop().catch(() => { });
+            this.sessions.delete(oldest.key);
+        }
+    }
+    // ─── Helpers ──────────────────────────────────────────────────────────────
+    resolvePath(p) {
+        return resolveSessionWorkDir(p);
+    }
+    resolveAuthorizedPath(p, rootPath) {
+        return resolveAuthorizedPath(p, createAuthorizedFsRoot(rootPath));
+    }
+    async resolveAuthorizedPathAsync(p, rootPath) {
+        return resolveAuthorizedPathAsync(p, await createAuthorizedFsRootAsync(rootPath));
+    }
+    async cleanup() {
+        this.nativeFusion?.setExternalTerminalHandler?.(null);
+        this.nativeCleanupOutbox.stop();
+        this.historySubscriptions.closeAll();
+        if (this.activityProbeTimer) {
+            clearInterval(this.activityProbeTimer);
+            this.activityProbeTimer = null;
+        }
+        if (this.attachmentCleanupTimer) {
+            clearInterval(this.attachmentCleanupTimer);
+            this.attachmentCleanupTimer = null;
+        }
+        for (const [, session] of this.sessions) {
+            this.revokeManagedRoomToken(session);
+            if (session.heartbeatTimer) {
+                clearInterval(session.heartbeatTimer);
+                session.heartbeatTimer = null;
+            }
+            await session.adapter.stop().catch(() => { });
+        }
+        this.sessions.clear();
+        this.runTextAcc.clear();
+        cleanupPendingTransfers(this.getRuntime());
+        await this.managerRuntime.stop();
+        setManagerRuntimeService(null);
+    }
+    revokeManagedRoomToken(session) {
+        const token = session.managedRoomContextToken;
+        session.managedRoomContextToken = null;
+        if (token)
+            this.managedRoomContextRevoker?.(token);
+    }
+}