@seawork/server 1.0.22-rc.3 → 2.0.2-rc.6

package/dist/server/server/session.js

@@ -1,5 +1,6 @@
 import { exec, execFile } from "node:child_process";
 import { homedir, tmpdir } from "node:os";
+import { TTLCache } from "@isaacs/ttlcache";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { experimental_createMCPClient } from "ai";
 import equal from "fast-deep-equal";
@@ -10,11 +11,10 @@ import { v4 as uuidv4 } from "uuid";
 import { z } from "zod";
 import { decodeTerminalResizePayload, encodeTerminalSnapshotPayload, encodeTerminalStreamFrame, TerminalStreamOpcode, } from "../shared/terminal-stream-protocol.js";
 import { captureTerminalLines } from "../terminal/terminal.js";
-import { commitChanges, createPullRequest, getCheckoutDiff, getCheckoutStatus, listBranchSuggestions, mergeFromBase, mergeToBase, pullCurrentBranch, pushCurrentBranch, } from "../utils/checkout-git.js";
+import { commitChanges, createPullRequest, getCachedCheckoutShortstat, getCheckoutDiff, getCheckoutStatus, hasWorkingTreeChanges, invalidateCheckoutShortstatCache, listBranchSuggestions, mergeFromBase, mergeToBase, pullCurrentBranch, pushCurrentBranch, warmCheckoutShortstatInBackground, } from "../utils/checkout-git.js";
 import { searchHomeDirectories, searchWorkspaceEntries } from "../utils/directory-suggestions.js";
 import { expandTilde } from "../utils/path.js";
 import { getProjectIcon } from "../utils/project-icon.js";
-import { latencyTracker } from "./latency-tracker.js";
 import { scheduleAgentMetadataGeneration } from "./agent/agent-metadata-generator.js";
 import { resolveEffectiveThinkingOptionId, toAgentPayload } from "./agent/agent-projections.js";
 import { DEFAULT_STRUCTURED_GENERATION_PROVIDERS, generateStructuredAgentResponseWithFallback, StructuredAgentFallbackError, StructuredAgentResponseError, } from "./agent/agent-response-loop.js";
@@ -33,22 +33,29 @@ import { notifyChatMentions } from "./chat/chat-mentions.js";
 import { ChatServiceError } from "./chat/chat-service.js";
 import { READ_ONLY_GIT_ENV, toCheckoutError } from "./checkout-git-utils.js";
 import { resolveClientMessageId } from "./client-message-id.js";
-import { fetchGitForgeIssues } from "./git-forge/service.js";
-import { redactGitForgeTokens, rehydratePatchTokens } from "./git-forge/token-mask.js";
 import { DictationStreamManager, } from "./dictation/dictation-stream-manager.js";
 import { listAvailableEditorTargets, openInEditorTarget } from "./editor-targets.js";
 import { createDirectoryEntry, createFileEntry, getDownloadableFileInfo, listDirectoryEntries, readExplorerFile, } from "./file-explorer/service.js";
-import { WorkspaceIgnoreStore } from "./workspace-ignore/store.js";
 import { handleGetPublicIssue, handleListIssueComments, handleListPublicIssues, handlePostIssueComment, handleToggleIssueReaction, } from "./forum-handler.js";
+import { discoverGitForgeIssueWork, fetchGitForgeIssues, transitionGitForgeIssueWork, } from "./git-forge/service.js";
+import { redactGitForgeTokens, rehydratePatchTokens } from "./git-forge/token-mask.js";
+import { fetchWeComOpenClawQrCode, queryWeComOpenClawQrResult, } from "./integrations/wecom-openclaw/qr.js";
+import { resolveWeComOpenClawAgentCwd } from "./integrations/wecom-openclaw/workspace.js";
+import { latencyTracker } from "./latency-tracker.js";
+import { handleHubTestRunCancel, handleHubTestRunStart } from "./library/hub-test-run.js";
+import { filterLibrarySkillCommands } from "./library/library-injection.js";
+import { handleLibraryRequest } from "./library/library-rpc.js";
 import { handleListMyIssues } from "./list-my-issues-handler.js";
-import { isLegacyEditorTargetId, serializeAgentStreamEvent, } from "./messages.js";
+import { isLegacyEditorTargetId, PROVIDER_ENV_VALUE_REDACTED, serializeAgentStreamEvent, } from "./messages.js";
 import { buildConfigOverrides, buildSessionConfig, extractTimestamps, } from "./persistence-hooks.js";
+import { redactProviderEnv, rehydratePatchProviderEnv } from "./provider-runtime-settings-mask.js";
 import { toResolver } from "./speech/provider-resolver.js";
 import { createVoiceTurnController, } from "./voice/voice-turn-controller.js";
 import { buildVoiceModeSystemPrompt, stripVoiceModeSystemPrompt, wrapSpokenInput, } from "./voice-config.js";
 import { isVoicePermissionAllowed } from "./voice-permission-policy.js";
+import { WorkspaceIgnoreStore } from "./workspace-ignore/store.js";
 import { createPersistedProjectRecord, createPersistedWorkspaceRecord, } from "./workspace-registry.js";
-import { buildProjectPlacementForCwd, deriveProjectKind, deriveProjectRootPath, deriveWorkspaceDisplayName, deriveWorkspaceId, deriveWorkspaceKind, detectStaleWorkspaces, normalizeWorkspaceId as normalizePersistedWorkspaceId, } from "./workspace-registry-model.js";
+import { buildProjectPlacementForCwd, deriveProjectKind, deriveProjectRootPath, deriveWorkspaceDisplayName, deriveWorkspaceId, deriveWorkspaceKind, detectStaleWorkspaces, normalizeWorkspaceId as normalizePersistedWorkspaceId, normalizeWorkspaceLookupKey, } from "./workspace-registry-model.js";
 import { runAsyncWorktreeBootstrap } from "./worktree-bootstrap.js";
 import { assertSafeGitRef as assertWorktreeSafeGitRef, buildAgentSessionConfig as buildWorktreeAgentSessionConfig, createSeaworkWorktreeInBackground as createWorktreeInBackgroundSession, handleCreateSeaworkWorktreeRequest as handleCreateWorktreeRequest, handleSeaworkWorktreeArchiveRequest as handleWorktreeArchiveRequest, handleSeaworkWorktreeListRequest as handleWorktreeListRequest, killTerminalsUnderPath as killWorktreeTerminalsUnderPath, registerPendingWorktreeWorkspace as registerPendingWorktreeWorkspaceSession, } from "./worktree-session.js";
 const execAsync = promisify(exec);
@@ -84,11 +91,30 @@ function clientSupportsAllProviders(appVersion) {
 function clientSupportsFlexibleEditorIds(appVersion) {
     return isAppVersionAtLeast(appVersion, MIN_VERSION_FLEXIBLE_EDITOR_IDS);
 }
+function clientSupportsTimelineErrorItems(appVersion) {
+    return isAppVersionAtLeast(appVersion, "1.0.34");
+}
+function clientSupportsTimelineReconnectingItems(appVersion) {
+    return isAppVersionAtLeast(appVersion, "1.0.39");
+}
+function legacyTimelineProjectionOptions(appVersion) {
+    return {
+        legacySystemErrorsAsAssistantMessage: !clientSupportsTimelineErrorItems(appVersion),
+        legacyReconnectingAsReasoning: !clientSupportsTimelineReconnectingItems(appVersion),
+    };
+}
 const MAX_TERMINAL_STREAM_SLOTS = 256;
 // Reuse the cached PR snapshot for this long before re-shelling out to `gh`.
 // Background watchers + periodic fetches keep it warm; the client polls every
 // 15s, so this dedupes overlapping panels without delaying real changes.
 const CHECKOUT_PR_STATUS_CACHE_TTL_MS = 10000;
+const AVAILABLE_EDITOR_TARGETS_CACHE_TTL_MS = 60000;
+const AVAILABLE_EDITOR_TARGETS_CACHE_KEY = "available";
+// Coalesces repeated buildProjectPlacement calls (each spawns 3+ git children)
+// across concurrent fetch_agents / fetch_workspaces requests. Slow disks or
+// missing-external-drive cwds previously caused tens of seconds of stacked git
+// invocations per cwd; see issue #635 / #770.
+const PROJECT_PLACEMENT_CACHE_TTL_MS = 5000;
 function computeCheckoutPrAgeMs(snap) {
     const t = snap?.github.refreshedAt;
     if (!t)
@@ -232,6 +258,164 @@ function toAgentPersistenceHandle(logger, handle) {
         metadata: handle.metadata,
     };
 }
+const OFFLINE_TIMELINE_EPOCH = "offline-persisted";
+const DEFAULT_OFFLINE_TIMELINE_FETCH_LIMIT = 200;
+function buildOfflineTimelineRows(items, timestamp) {
+    return items.map((item, index) => ({
+        seq: index + 1,
+        timestamp,
+        item,
+    }));
+}
+function selectOfflineTimelineWindow(params) {
+    const rows = buildOfflineTimelineRows(params.items, params.timestamp);
+    const direction = params.direction;
+    const limit = params.limit === undefined
+        ? DEFAULT_OFFLINE_TIMELINE_FETCH_LIMIT
+        : Math.max(0, Math.floor(params.limit));
+    const minSeq = rows.length ? rows[0].seq : 0;
+    const maxSeq = rows.length ? rows[rows.length - 1].seq : 0;
+    const nextSeq = maxSeq + 1;
+    const window = { minSeq, maxSeq, nextSeq };
+    const cloneRows = (selected) => selected.map((row) => ({ ...row }));
+    const selectAll = limit === 0;
+    if (params.cursor && params.cursor.epoch !== OFFLINE_TIMELINE_EPOCH) {
+        return {
+            agentProvider: params.agentProvider,
+            epoch: OFFLINE_TIMELINE_EPOCH,
+            reset: true,
+            staleCursor: true,
+            gap: false,
+            window,
+            hasOlder: false,
+            hasNewer: false,
+            rows: cloneRows(rows),
+        };
+    }
+    if (direction === "after" && params.cursor && rows.length > 0 && params.cursor.seq < minSeq - 1) {
+        return {
+            agentProvider: params.agentProvider,
+            epoch: OFFLINE_TIMELINE_EPOCH,
+            reset: true,
+            staleCursor: false,
+            gap: true,
+            window,
+            hasOlder: false,
+            hasNewer: false,
+            rows: cloneRows(rows),
+        };
+    }
+    if (rows.length === 0) {
+        return {
+            agentProvider: params.agentProvider,
+            epoch: OFFLINE_TIMELINE_EPOCH,
+            reset: false,
+            staleCursor: false,
+            gap: false,
+            window,
+            hasOlder: false,
+            hasNewer: false,
+            rows: [],
+        };
+    }
+    if (direction === "tail") {
+        const selected = selectAll || limit >= rows.length ? rows : rows.slice(rows.length - limit);
+        return {
+            agentProvider: params.agentProvider,
+            epoch: OFFLINE_TIMELINE_EPOCH,
+            reset: false,
+            staleCursor: false,
+            gap: false,
+            window,
+            hasOlder: selected.length > 0 && selected[0].seq > minSeq,
+            hasNewer: false,
+            rows: cloneRows(selected),
+        };
+    }
+    if (direction === "after") {
+        const baseSeq = params.cursor?.seq ?? 0;
+        const startIdx = rows.findIndex((row) => row.seq > baseSeq);
+        if (startIdx < 0) {
+            return {
+                agentProvider: params.agentProvider,
+                epoch: OFFLINE_TIMELINE_EPOCH,
+                reset: false,
+                staleCursor: false,
+                gap: false,
+                window,
+                hasOlder: baseSeq >= minSeq,
+                hasNewer: false,
+                rows: [],
+            };
+        }
+        const selected = selectAll ? rows.slice(startIdx) : rows.slice(startIdx, startIdx + limit);
+        const lastSelected = selected[selected.length - 1];
+        return {
+            agentProvider: params.agentProvider,
+            epoch: OFFLINE_TIMELINE_EPOCH,
+            reset: false,
+            staleCursor: false,
+            gap: false,
+            window,
+            hasOlder: selected[0].seq > minSeq,
+            hasNewer: Boolean(lastSelected && lastSelected.seq < maxSeq),
+            rows: cloneRows(selected),
+        };
+    }
+    const beforeSeq = params.cursor?.seq ?? nextSeq;
+    const endExclusive = rows.findIndex((row) => row.seq >= beforeSeq);
+    const boundedRows = endExclusive < 0 ? rows : rows.slice(0, endExclusive);
+    const selected = selectAll || limit >= boundedRows.length
+        ? boundedRows
+        : boundedRows.slice(boundedRows.length - limit);
+    return {
+        agentProvider: params.agentProvider,
+        epoch: OFFLINE_TIMELINE_EPOCH,
+        reset: false,
+        staleCursor: false,
+        gap: false,
+        window,
+        hasOlder: selected.length > 0 && selected[0].seq > minSeq,
+        hasNewer: endExclusive >= 0,
+        rows: cloneRows(selected),
+    };
+}
+function projectOfflineTimelineFetchResponse(params) {
+    let hasOlder = params.model.hasOlder;
+    let hasNewer = params.model.hasNewer;
+    let startCursor = null;
+    let endCursor = null;
+    let entries;
+    if (params.shouldLimitByProjectedWindow) {
+        const projectedLimit = Math.max(1, Math.floor(params.requestedLimit ?? 1));
+        const projectedWindow = selectTimelineWindowByProjectedLimit({
+            rows: params.model.rows,
+            provider: params.model.agentProvider,
+            direction: params.direction,
+            limit: projectedLimit,
+            collapseToolLifecycle: false,
+        });
+        entries = projectTimelineRows(projectedWindow.selectedRows, params.model.agentProvider, params.projection, params.projectionOptions);
+        if (projectedWindow.minSeq !== null && projectedWindow.maxSeq !== null) {
+            startCursor = { epoch: params.model.epoch, seq: projectedWindow.minSeq };
+            endCursor = { epoch: params.model.epoch, seq: projectedWindow.maxSeq };
+            hasOlder = projectedWindow.minSeq > params.model.window.minSeq;
+            hasNewer = false;
+        }
+    }
+    else {
+        const firstRow = params.model.rows[0];
+        const lastRow = params.model.rows[params.model.rows.length - 1];
+        startCursor = firstRow ? { epoch: params.model.epoch, seq: firstRow.seq } : null;
+        endCursor = lastRow ? { epoch: params.model.epoch, seq: lastRow.seq } : null;
+        entries = projectTimelineRows(params.model.rows, params.model.agentProvider, params.projection, params.projectionOptions);
+    }
+    return { entries, startCursor, endCursor, hasOlder, hasNewer };
+}
+export const __sessionTimelineInternals = {
+    projectOfflineTimelineFetchResponse,
+    selectOfflineTimelineWindow,
+};
 /**
  * Session represents a single connected client session.
  * It owns all state management, orchestration logic, and message processing.
@@ -259,11 +443,14 @@ export class Session {
         // Per-session MCP client and tools
         this.agentMcpClient = null;
         this.agentTools = null;
+        /** In-flight Hub "test run" sandboxes, keyed by requestId, for cancellation. */
+        this.hubTestRuns = new Map();
         this.unsubscribeAgentEvents = null;
         this.agentUpdatesSubscription = null;
         this.workspaceUpdatesSubscription = null;
         this.clientActivity = null;
         this.MOBILE_BACKGROUND_STREAM_GRACE_MS = 60000;
+        this.wecomOpenClawQr = null;
         this.unsubscribeProviderSnapshotEvents = null;
         this.subscribedTerminalDirectories = new Set();
         this.unsubscribeTerminalsChanged = null;
@@ -273,6 +460,18 @@ export class Session {
         this.nextTerminalSlot = 0;
         this.inflightRequests = 0;
         this.peakInflightRequests = 0;
+        this.availableEditorTargetsCache = new TTLCache({
+            ttl: AVAILABLE_EDITOR_TARGETS_CACHE_TTL_MS,
+            max: 1,
+            checkAgeOnGet: true,
+        });
+        this.availableEditorTargetsInflight = null;
+        this.projectPlacementCache = new TTLCache({
+            ttl: PROJECT_PLACEMENT_CACHE_TTL_MS,
+            max: 500,
+            checkAgeOnGet: true,
+        });
+        this.projectPlacementInflight = new Map();
         this.bugReportWsMessageRing = [];
         this.checkoutDiffSubscriptions = new Map();
         this.workspaceGitSubscriptions = new Map();
@@ -285,7 +484,7 @@ export class Session {
             attention: 3,
             done: 4,
         };
-        const { clientId, appVersion, onMessage, onBinaryMessage, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, seaworkHome, agentManager, agentStorage, projectRegistry, workspaceRegistry, chatService, scheduleService, loopService, checkoutDiffManager, workspaceGitService, daemonConfigStore, mcpBaseUrl, stt, tts, terminalManager, providerSnapshotManager, voice, voiceBridge, dictation, agentProviderRuntimeSettings, } = options;
+        const { clientId, appVersion, onMessage, onBinaryMessage, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, seaworkHome, agentManager, agentStorage, projectRegistry, workspaceRegistry, chatService, scheduleService, loopService, checkoutDiffManager, workspaceGitService, daemonConfigStore, mcpBaseUrl, stt, tts, terminalManager, providerSnapshotManager, voice, voiceBridge, dictation, agentProviderRuntimeSettings, library, broadcastLibraryUpdate, } = options;
         this.clientId = clientId;
         this.appVersion = appVersion;
         this.sessionId = uuidv4();
@@ -306,6 +505,8 @@ export class Session {
         this.workspaceGitService = workspaceGitService;
         this.daemonConfigStore = daemonConfigStore;
         this.mcpBaseUrl = mcpBaseUrl ?? null;
+        this.library = library ?? null;
+        this.broadcastLibraryUpdate = broadcastLibraryUpdate ?? null;
         this.terminalManager = terminalManager;
         this.providerSnapshotManager = providerSnapshotManager ?? null;
         if (this.terminalManager) {
@@ -574,15 +775,20 @@ export class Session {
                     }
                 }
             }
-            const serializedEvent = serializeAgentStreamEvent(event.event);
+            const serializedEvent = serializeAgentStreamEvent(event.event, {
+                ...legacyTimelineProjectionOptions(this.appVersion),
+            });
             if (!serializedEvent) {
                 return;
             }
-            // Log timing for key stream events
+            // Log timing for key stream events. "timeline" is intentionally
+            // excluded: it fires once per delta, so a long turn floods daemon.log
+            // and evicts the real turn_failed error from the bug-report tail
+            // window (#1215). Keep only the once-per-turn markers.
             const evtType = event.event.type;
-            if (evtType === "timeline" ||
-                evtType === "turn_completed" ||
+            if (evtType === "turn_completed" ||
                 evtType === "turn_failed" ||
+                evtType === "turn_canceled" ||
                 evtType === "usage_updated") {
                 this.sessionLogger.info({
                     agentId: event.agentId,
@@ -717,6 +923,7 @@ export class Session {
     async ensureAgentLoaded(agentId) {
         const existing = this.agentManager.getAgent(agentId);
         if (existing) {
+            await this.agentManager.hydrateTimelineFromProvider(agentId);
             return existing;
         }
         const inflight = pendingAgentInitializations.get(agentId);
@@ -753,6 +960,36 @@ export class Session {
             }
         }
     }
+    async loadOfflineTimelineForStoredAgent(params) {
+        const record = await this.agentStorage.get(params.agentId);
+        if (!record) {
+            return null;
+        }
+        const handle = toAgentPersistenceHandle(this.sessionLogger, record.persistence);
+        if (!handle) {
+            return null;
+        }
+        const provider = coerceAgentProvider(this.sessionLogger, record.provider, record.id);
+        const client = this.providerRegistry[provider]?.createClient(this.sessionLogger);
+        if (!client?.loadPersistedTimeline) {
+            return null;
+        }
+        const items = await client.loadPersistedTimeline(handle);
+        if (items.length === 0) {
+            return null;
+        }
+        return {
+            record,
+            model: selectOfflineTimelineWindow({
+                agentProvider: provider,
+                items,
+                direction: params.direction,
+                cursor: params.cursor,
+                limit: params.limit,
+                timestamp: this.resolveStoredAgentPayloadUpdatedAt(record),
+            }),
+        };
+    }
     // TODO: Remove once all app store clients are on >=0.1.45.
     isProviderVisibleToClient(provider) {
         if (clientSupportsAllProviders(this.appVersion))
@@ -852,10 +1089,27 @@ export class Session {
         }
     }
     async buildProjectPlacement(cwd) {
-        return buildProjectPlacementForCwd({
+        const cached = this.projectPlacementCache.get(cwd);
+        if (cached) {
+            return cached;
+        }
+        const inflight = this.projectPlacementInflight.get(cwd);
+        if (inflight) {
+            return inflight;
+        }
+        const promise = buildProjectPlacementForCwd({
             cwd,
             seaworkHome: this.seaworkHome,
+        })
+            .then((placement) => {
+            this.projectPlacementCache.set(cwd, placement);
+            return placement;
+        })
+            .finally(() => {
+            this.projectPlacementInflight.delete(cwd);
         });
+        this.projectPlacementInflight.set(cwd, promise);
+        return promise;
     }
     buildPersistedProjectRecord(input) {
         return createPersistedProjectRecord({
@@ -1106,6 +1360,36 @@ export class Session {
                     case "toggle_issue_reaction_request":
                         await this.handleToggleIssueReactionRequest(msg);
                         break;
+                    case "library_list_request":
+                    case "library_upsert_mcp_request":
+                    case "library_upsert_skill_request":
+                    case "library_delete_request":
+                    case "library_set_autoattach_request":
+                    case "library_import_existing_request":
+                    case "library_install_from_hub_request":
+                    case "library_uninstall_from_hub_request": {
+                        const response = await handleLibraryRequest(msg, {
+                            library: this.library,
+                            seaworkHome: this.seaworkHome,
+                            logger: this.sessionLogger,
+                            broadcastUpdate: (snapshot) => this.broadcastLibraryUpdate?.(snapshot),
+                        });
+                        this.emit(response);
+                        break;
+                    }
+                    case "hub_test_run_start_request": {
+                        const done = await handleHubTestRunStart(msg, {
+                            codexClient: this.providerRegistry.codex.createClient(this.sessionLogger),
+                            logger: this.sessionLogger,
+                            emitChunk: (chunk) => this.emit(chunk),
+                            inFlight: this.hubTestRuns,
+                        });
+                        this.emit(done);
+                        break;
+                    }
+                    case "hub_test_run_cancel_request":
+                        handleHubTestRunCancel(msg.requestId, this.hubTestRuns);
+                        break;
                     case "archive_agent_request":
                         await this.handleArchiveAgentRequest(msg.agentId, msg.requestId);
                         break;
@@ -1129,25 +1413,41 @@ export class Session {
                             type: "get_daemon_config_response",
                             payload: {
                                 requestId: msg.requestId,
-                                config: redactGitForgeTokens(this.daemonConfigStore.get()),
+                                config: this.redactDaemonConfig(this.daemonConfigStore.get()),
                             },
                         });
                         break;
                     case "set_daemon_config_request": {
-                        const rehydrated = rehydratePatchTokens({
+                        const tokenRehydrated = rehydratePatchTokens({
                             patch: msg.config,
                             current: this.daemonConfigStore.get(),
                         });
-                        const next = this.daemonConfigStore.patch(rehydrated);
+                        const providerEnvRehydrated = rehydratePatchProviderEnv({
+                            patch: tokenRehydrated,
+                            current: this.daemonConfigStore.get(),
+                        });
+                        const rehydrated = rehydratePatchWeComOpenClawSecret({
+                            patch: providerEnvRehydrated,
+                            current: this.daemonConfigStore.get(),
+                        });
+                        const cwdResolved = resolvePatchWeComOpenClawAgentCwd({
+                            patch: rehydrated,
+                            seaworkHome: this.seaworkHome,
+                        });
+                        const promptInjectionResolved = resolvePatchPromptInjectionCwds(cwdResolved);
+                        const next = this.daemonConfigStore.patch(promptInjectionResolved);
                         this.emit({
                             type: "set_daemon_config_response",
                             payload: {
                                 requestId: msg.requestId,
-                                config: redactGitForgeTokens(next),
+                                config: this.redactDaemonConfig(next),
                             },
                         });
                         break;
                     }
+                    case "wecom_openclaw_qr_request":
+                        await this.handleWeComOpenClawQrRequest(msg.requestId, msg.poll === true);
+                        break;
                     case "fetch_git_forge_issues_request": {
                         const result = await fetchGitForgeIssues({ workspaceId: msg.workspaceId, cwd: msg.cwd }, {
                             configStore: this.daemonConfigStore,
@@ -1162,6 +1462,41 @@ export class Session {
                         });
                         break;
                     }
+                    case "discover_git_forge_issue_work_request": {
+                        const result = await discoverGitForgeIssueWork({ workspaceId: msg.workspaceId, cwd: msg.cwd, number: msg.number }, {
+                            configStore: this.daemonConfigStore,
+                            workspaceRegistry: this.workspaceRegistry,
+                            agentManager: this.agentManager,
+                            seaworkHome: this.seaworkHome,
+                        });
+                        this.emit({
+                            type: "discover_git_forge_issue_work_response",
+                            payload: {
+                                requestId: msg.requestId,
+                                result,
+                            },
+                        });
+                        break;
+                    }
+                    case "transition_git_forge_issue_work_request": {
+                        const result = await transitionGitForgeIssueWork({
+                            workspaceId: msg.workspaceId,
+                            cwd: msg.cwd,
+                            number: msg.number,
+                            source: msg.source,
+                        }, {
+                            configStore: this.daemonConfigStore,
+                            workspaceRegistry: this.workspaceRegistry,
+                        });
+                        this.emit({
+                            type: "transition_git_forge_issue_work_response",
+                            payload: {
+                                requestId: msg.requestId,
+                                result,
+                            },
+                        });
+                        break;
+                    }
                     case "dictation_stream_start":
                         {
                             const unavailable = this.resolveVoiceFeatureUnavailableContext("dictation");
@@ -1448,6 +1783,12 @@ export class Session {
                     case "schedule/resume":
                         await this.handleScheduleResumeRequest(msg);
                         break;
+                    case "schedule/update":
+                        await this.handleScheduleUpdateRequest(msg);
+                        break;
+                    case "schedule/run-now":
+                        await this.handleScheduleRunNowRequest(msg);
+                        break;
                     case "schedule/delete":
                         await this.handleScheduleDeleteRequest(msg);
                         break;
@@ -1646,6 +1987,7 @@ export class Session {
                 focusedAgentId: this.clientActivity?.focusedAgentId,
             }),
             getWsMessageRing: () => this.getBugReportWsMessageRing(),
+            getRecentTurnTraces: () => this.agentManager.getBugReportTurnTraces(),
         });
         this.emit(response);
     }
@@ -2186,7 +2528,7 @@ export class Session {
     /**
      * Handle text message to agent (with optional image + document attachments)
      */
-    async handleSendAgentMessage(agentId, text, messageId, images, runOptions, options, documents) {
+    async handleSendAgentMessage(agentId, text, messageId, images, runOptions, options, documents, imageAttachments) {
         this.sessionLogger.info({
             agentId,
             textPreview: text.substring(0, 50),
@@ -2195,7 +2537,14 @@ export class Session {
         }, `Sending text to agent ${agentId}${images && images.length > 0 ? ` with ${images.length} image attachment(s)` : ""}${documents && documents.length > 0 ? ` with ${documents.length} document attachment(s)` : ""}`);
         await this.unarchiveAgentState(agentId);
         try {
-            await this.ensureAgentLoaded(agentId);
+            if (options?.skipAgentLoad) {
+                if (!this.agentManager.getAgent(agentId)) {
+                    throw new Error(`Agent not found: ${agentId}`);
+                }
+            }
+            else {
+                await this.ensureAgentLoaded(agentId);
+            }
         }
         catch (error) {
             this.handleAgentRunError(agentId, error, "Failed to initialize agent before sending prompt");
@@ -2207,12 +2556,26 @@ export class Session {
         try {
             this.agentManager.recordUserMessage(agentId, text, {
                 messageId,
+                images: imageAttachments,
                 emitState: false,
             });
         }
         catch (error) {
             this.sessionLogger.error({ err: error, agentId }, `Failed to record user message for agent ${agentId}`);
         }
+        // Out-of-band slash commands (e.g. /goal) are handled as a side effect
+        // without allocating a turn. Spoken input is never treated as a command.
+        if (!options?.spokenInput) {
+            const oob = await this.agentManager.tryRunOutOfBand(agentId, text);
+            if (oob) {
+                await this.agentManager.appendTimelineItem(agentId, {
+                    type: "assistant_message",
+                    text: oob.response,
+                });
+                this.agentManager.emitAgentState(agentId);
+                return { ok: true };
+            }
+        }
         const promptText = options?.spokenInput ? wrapSpokenInput(text) : text;
         const prompt = this.buildAgentPrompt(promptText, images, documents);
         return this.startAgentStream(agentId, prompt, runOptions);
@@ -2221,7 +2584,7 @@ export class Session {
      * Handle create agent request
      */
     async handleCreateAgentRequest(msg) {
-        const { config, worktreeName, requestId, initialPrompt, clientMessageId, outputSchema, git, images, documents, labels, } = msg;
+        const { config, worktreeName, requestId, initialPrompt, clientMessageId, outputSchema, git, images, imageAttachments, documents, labels, } = msg;
         this.sessionLogger.info({ cwd: config.cwd, provider: config.provider, worktreeName }, `Creating agent in ${config.cwd} (${config.provider})${worktreeName ? ` with worktree ${worktreeName}` : ""}`);
         try {
             const trimmedPrompt = initialPrompt?.trim();
@@ -2250,7 +2613,7 @@ export class Session {
                     seaworkHome: this.seaworkHome,
                     logger: this.sessionLogger,
                 });
-                const started = await this.handleSendAgentMessage(snapshot.id, trimmedPrompt, resolveClientMessageId(clientMessageId), images, outputSchema ? { outputSchema } : undefined, undefined, documents);
+                const started = await this.handleSendAgentMessage(snapshot.id, trimmedPrompt, resolveClientMessageId(clientMessageId), images, outputSchema ? { outputSchema } : undefined, { skipAgentLoad: true }, documents, imageAttachments);
                 if (!started.ok) {
                     throw new Error(started.error);
                 }
@@ -2428,6 +2791,7 @@ export class Session {
             const sessions = await this.agentManager.listPersistedAgents({
                 ...(provider ? { provider } : {}),
                 ...(fetchLimit !== undefined ? { limit: fetchLimit } : {}),
+                ...(includeTimeline ? { includeTimeline: true } : {}),
             });
             // Only claim sessions that are currently live — archived Seawork records
             // should reappear in the Resume list so the user can pick them back up
@@ -2552,34 +2916,99 @@ export class Session {
         }, config, gitOptions, legacyWorktreeName, _labels);
     }
     async handleListProviderModelsRequest(msg) {
+        const cwd = msg.cwd ? expandTilde(msg.cwd) : undefined;
         const fetchedAt = new Date().toISOString();
-        try {
-            const models = await this.providerRegistry[msg.provider].fetchModels({
-                cwd: msg.cwd ? expandTilde(msg.cwd) : undefined,
-            });
+        const providerDefinition = this.providerRegistry[msg.provider];
+        const manager = this.providerSnapshotManager;
+        if (!providerDefinition) {
             this.emit({
                 type: "list_provider_models_response",
                 payload: {
                     provider: msg.provider,
-                    models,
-                    error: null,
+                    models: [],
+                    error: `Unknown provider: ${msg.provider}`,
                     fetchedAt,
                     requestId: msg.requestId,
                 },
             });
+            return;
         }
-        catch (error) {
-            this.sessionLogger.error({ err: error, provider: msg.provider }, `Failed to list models for ${msg.provider}`);
+        if (!manager) {
+            try {
+                const models = await providerDefinition.fetchModels({ cwd });
+                this.emit({
+                    type: "list_provider_models_response",
+                    payload: {
+                        provider: msg.provider,
+                        models,
+                        error: null,
+                        fetchedAt,
+                        requestId: msg.requestId,
+                    },
+                });
+            }
+            catch (error) {
+                this.sessionLogger.error({ err: error, provider: msg.provider }, `Failed to list models for ${msg.provider}`);
+                this.emit({
+                    type: "list_provider_models_response",
+                    payload: {
+                        provider: msg.provider,
+                        models: [],
+                        error: error?.message ?? String(error),
+                        fetchedAt,
+                        requestId: msg.requestId,
+                    },
+                });
+            }
+            return;
+        }
+        // Route through the snapshot manager so simultaneous calls dedupe through
+        // the in-flight warmup and cached entries are served without re-spawning.
+        const findEntry = () => manager.getSnapshot(cwd).find((candidate) => candidate.provider === msg.provider);
+        let entry = findEntry();
+        if (!entry || entry.status === "loading") {
+            await manager.ensureSnapshot(cwd);
+            entry = findEntry();
+        }
+        if (!entry) {
             this.emit({
                 type: "list_provider_models_response",
                 payload: {
                     provider: msg.provider,
-                    error: error?.message ?? String(error),
+                    models: [],
+                    error: `Unknown provider: ${msg.provider}`,
                     fetchedAt,
                     requestId: msg.requestId,
                 },
             });
+            return;
+        }
+        if (entry.status === "ready") {
+            this.emit({
+                type: "list_provider_models_response",
+                payload: {
+                    provider: msg.provider,
+                    models: entry.models ?? [],
+                    error: null,
+                    fetchedAt: entry.fetchedAt ?? fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+            return;
         }
+        const errorMessage = entry.status === "error"
+            ? (entry.error ?? `Failed to list models for ${msg.provider}`)
+            : `Provider ${msg.provider} is not available`;
+        this.emit({
+            type: "list_provider_models_response",
+            payload: {
+                provider: msg.provider,
+                models: [],
+                error: errorMessage,
+                fetchedAt,
+                requestId: msg.requestId,
+            },
+        });
     }
     async handleListProviderModesRequest(msg) {
         const fetchedAt = new Date().toISOString();
@@ -2621,6 +3050,12 @@ export class Session {
             ...(draftConfig.featureValues ? { featureValues: draftConfig.featureValues } : {}),
         };
     }
+    async filterLibraryCommands(commands, config) {
+        if (!this.library || (config.provider !== "claude" && config.provider !== "codex")) {
+            return commands;
+        }
+        return filterLibrarySkillCommands(commands, await this.library.load(), config.provider, config.perAgentDisabled);
+    }
     async handleListProviderFeaturesRequest(msg) {
         const fetchedAt = new Date().toISOString();
         try {
@@ -2710,6 +3145,94 @@ export class Session {
             },
         });
     }
+    redactDaemonConfig(config) {
+        const redacted = redactProviderEnv(redactGitForgeTokens(config));
+        const wecomOpenClaw = redacted.integrations?.wecomOpenClaw;
+        if (!wecomOpenClaw?.secret) {
+            return redacted;
+        }
+        return {
+            ...redacted,
+            integrations: {
+                ...redacted.integrations,
+                wecomOpenClaw: {
+                    ...wecomOpenClaw,
+                    secret: "<configured>",
+                },
+            },
+        };
+    }
+    async handleWeComOpenClawQrRequest(requestId, poll) {
+        try {
+            if (!this.wecomOpenClawQr || !poll) {
+                this.wecomOpenClawQr = await fetchWeComOpenClawQrCode();
+            }
+            const qr = this.wecomOpenClawQr;
+            const credentials = await queryWeComOpenClawQrResult(qr.scode);
+            if (!credentials) {
+                this.emit({
+                    type: "wecom_openclaw_qr_response",
+                    payload: {
+                        requestId,
+                        status: "pending",
+                        scode: qr.scode,
+                        authUrl: qr.authUrl,
+                        qrPageUrl: qr.qrPageUrl,
+                        config: null,
+                        error: null,
+                    },
+                });
+                return;
+            }
+            const currentWeCom = this.daemonConfigStore.get().integrations?.wecomOpenClaw ?? {};
+            const allowUsers = mergeUniqueNonEmptyStrings(currentWeCom.allowUsers, credentials.authorizedUserId ? [credentials.authorizedUserId] : []);
+            const hasAllowlist = allowUsers.length > 0 || normalizeNonEmptyStrings(currentWeCom.allowChats).length > 0;
+            const pendingAllowFirstUser = !hasAllowlist;
+            const cwd = resolveWeComOpenClawAgentCwd(currentWeCom.cwd, this.seaworkHome);
+            const next = this.daemonConfigStore.patch({
+                integrations: {
+                    wecomOpenClaw: {
+                        ...currentWeCom,
+                        enabled: hasAllowlist || pendingAllowFirstUser,
+                        botId: credentials.botId,
+                        secret: credentials.secret,
+                        cwd,
+                        provider: currentWeCom.provider ?? DEFAULT_AGENT_PROVIDER,
+                        agentMode: currentWeCom.agentMode ?? "new",
+                        allowUsers,
+                        pendingAllowFirstUser,
+                    },
+                },
+            });
+            this.wecomOpenClawQr = null;
+            this.emit({
+                type: "wecom_openclaw_qr_response",
+                payload: {
+                    requestId,
+                    status: "success",
+                    scode: qr.scode,
+                    authUrl: qr.authUrl,
+                    qrPageUrl: qr.qrPageUrl,
+                    config: this.redactDaemonConfig(next),
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emit({
+                type: "wecom_openclaw_qr_response",
+                payload: {
+                    requestId,
+                    status: "error",
+                    scode: this.wecomOpenClawQr?.scode ?? null,
+                    authUrl: this.wecomOpenClawQr?.authUrl ?? null,
+                    qrPageUrl: this.wecomOpenClawQr?.qrPageUrl ?? null,
+                    config: null,
+                    error: formatUnknownError(error),
+                },
+            });
+        }
+    }
     async handleRefreshProvidersSnapshotRequest(msg) {
         this.providerSnapshotManager?.refresh(msg.cwd ? expandTilde(msg.cwd) : undefined);
         this.emit({
@@ -2877,22 +3400,16 @@ export class Session {
         }
     }
     async ensureCleanWorkingTree(cwd) {
-        const dirty = await this.isWorkingTreeDirty(cwd);
-        if (dirty) {
-            throw new Error("Working directory has uncommitted changes. Commit or stash before switching branches.");
-        }
-    }
-    async isWorkingTreeDirty(cwd) {
+        let dirty;
         try {
-            const { stdout } = await execAsync("git status --porcelain", {
-                cwd,
-                env: READ_ONLY_GIT_ENV,
-            });
-            return stdout.trim().length > 0;
+            dirty = await hasWorkingTreeChanges(cwd);
         }
         catch (error) {
             throw new Error(`Unable to inspect git status for ${cwd}: ${error.message}`);
         }
+        if (dirty) {
+            throw new Error("Working directory has uncommitted changes. Commit or stash before switching branches.");
+        }
     }
     async checkoutExistingBranch(cwd, branch) {
         this.assertSafeGitRef(branch, "branch");
@@ -3100,6 +3617,7 @@ export class Session {
             lastActivityAt: new Date(msg.lastActivityAt),
             appVisible: msg.appVisible,
             appVisibilityChangedAt,
+            desktopRuntime: msg.desktopRuntime ?? null,
         };
     }
     /**
@@ -3119,7 +3637,8 @@ export class Session {
             const agents = this.agentManager.listAgents();
             const agent = agents.find((a) => a.id === agentId);
             if (agent?.session?.listCommands) {
-                const commands = await agent.session.listCommands();
+                await this.agentManager.refreshLibrarySkillPolicy(agent.id);
+                const commands = await this.filterLibraryCommands(await agent.session.listCommands(), agent.config);
                 this.emit({
                     type: "list_commands_response",
                     payload: {
@@ -3133,7 +3652,7 @@ export class Session {
             }
             if (!agent && draftConfig) {
                 const sessionConfig = this.buildDraftAgentSessionConfig(draftConfig);
-                const commands = await this.agentManager.listDraftCommands(sessionConfig);
+                const commands = await this.filterLibraryCommands(await this.agentManager.listDraftCommands(sessionConfig), sessionConfig);
                 this.emit({
                     type: "list_commands_response",
                     payload: {
@@ -3479,6 +3998,8 @@ export class Session {
         try {
             await this.checkoutExistingBranch(cwd, branch);
             this.checkoutDiffManager.scheduleRefreshForCwd(cwd);
+            invalidateCheckoutShortstatCache(cwd);
+            void this.workspaceGitService.refresh(cwd, { priority: "high" });
             // Push a workspace_update immediately so the sidebar/header reflect
             // the new branch name without waiting for the background git watcher.
             await this.emitWorkspaceUpdateForCwd(cwd);
@@ -3514,7 +4035,9 @@ export class Session {
                 ? `${Session.SEAWORK_STASH_PREFIX} ${branchLabel}`
                 : `${Session.SEAWORK_STASH_PREFIX} unnamed`;
             await execFileAsync("git", ["stash", "push", "--include-untracked", "-m", message], { cwd });
+            invalidateCheckoutShortstatCache(cwd);
             this.checkoutDiffManager.scheduleRefreshForCwd(cwd);
+            void this.workspaceGitService.refresh(cwd, { priority: "high" });
             this.emit({
                 type: "stash_save_response",
                 payload: { cwd, success: true, error: null, requestId },
@@ -3531,7 +4054,9 @@ export class Session {
         const { cwd, stashIndex, requestId } = msg;
         try {
             await execFileAsync("git", ["stash", "pop", `stash@{${stashIndex}}`], { cwd });
+            invalidateCheckoutShortstatCache(cwd);
             this.checkoutDiffManager.scheduleRefreshForCwd(cwd);
+            void this.workspaceGitService.refresh(cwd, { priority: "high" });
             this.emit({
                 type: "stash_pop_response",
                 payload: { cwd, success: true, error: null, requestId },
@@ -3599,7 +4124,9 @@ export class Session {
                 message,
                 addAll: msg.addAll ?? true,
             });
+            invalidateCheckoutShortstatCache(cwd);
             this.checkoutDiffManager.scheduleRefreshForCwd(cwd);
+            void this.workspaceGitService.refresh(cwd, { priority: "high" });
             this.emit({
                 type: "checkout_commit_response",
                 payload: {
@@ -3643,11 +4170,7 @@ export class Session {
                 }
             }
             if (msg.requireCleanTarget) {
-                const { stdout } = await execAsync("git status --porcelain", {
-                    cwd,
-                    env: READ_ONLY_GIT_ENV,
-                });
-                if (stdout.trim().length > 0) {
+                if (await hasWorkingTreeChanges(cwd)) {
                     throw new Error("Working directory has uncommitted changes.");
                 }
             }
@@ -3658,11 +4181,13 @@ export class Session {
             if (baseRef.startsWith("origin/")) {
                 baseRef = baseRef.slice("origin/".length);
             }
-            await mergeToBase(cwd, {
+            const mutatedCwd = await mergeToBase(cwd, {
                 baseRef,
                 mode: msg.strategy === "squash" ? "squash" : "merge",
             }, { seaworkHome: this.seaworkHome });
             this.checkoutDiffManager.scheduleRefreshForCwd(cwd);
+            invalidateCheckoutShortstatCache(mutatedCwd);
+            void this.workspaceGitService.refresh(mutatedCwd, { priority: "high" });
             this.emit({
                 type: "checkout_merge_response",
                 payload: {
@@ -3689,11 +4214,7 @@ export class Session {
         const { cwd, requestId } = msg;
         try {
             if (msg.requireCleanTarget ?? true) {
-                const { stdout } = await execAsync("git status --porcelain", {
-                    cwd,
-                    env: READ_ONLY_GIT_ENV,
-                });
-                if (stdout.trim().length > 0) {
+                if (await hasWorkingTreeChanges(cwd)) {
                     throw new Error("Working directory has uncommitted changes.");
                 }
             }
@@ -3702,6 +4223,8 @@ export class Session {
                 requireCleanTarget: msg.requireCleanTarget ?? true,
             });
             this.checkoutDiffManager.scheduleRefreshForCwd(cwd);
+            invalidateCheckoutShortstatCache(cwd);
+            void this.workspaceGitService.refresh(cwd, { priority: "high" });
             this.emit({
                 type: "checkout_merge_from_base_response",
                 payload: {
@@ -3729,6 +4252,8 @@ export class Session {
         try {
             await pullCurrentBranch(cwd);
             this.checkoutDiffManager.scheduleRefreshForCwd(cwd);
+            invalidateCheckoutShortstatCache(cwd);
+            void this.workspaceGitService.refresh(cwd, { priority: "high" });
             this.emit({
                 type: "checkout_pull_response",
                 payload: {
@@ -3755,6 +4280,8 @@ export class Session {
         const { cwd, requestId } = msg;
         try {
             await pushCurrentBranch(cwd);
+            invalidateCheckoutShortstatCache(cwd);
+            void this.workspaceGitService.refresh(cwd, { priority: "high" });
             this.emit({
                 type: "checkout_push_response",
                 payload: {
@@ -3794,6 +4321,8 @@ export class Session {
                 body,
                 base: msg.baseRef,
             });
+            invalidateCheckoutShortstatCache(cwd);
+            void this.workspaceGitService.refresh(cwd, { priority: "high" });
             this.emit({
                 type: "checkout_pr_create_response",
                 payload: {
@@ -3938,7 +4467,17 @@ export class Session {
             }
         }
         catch (error) {
-            this.sessionLogger.error({ err: error, cwd, path: requestedPath }, `Failed to fulfill file explorer request for workspace ${cwd}`);
+            // Workspace on a removable drive that's been ejected — log at WARN so
+            // a power user with a flaky external disk doesn't fill daemon.log with
+            // ERROR-level entries for an expected condition. See issue #662 / #632.
+            const code = error?.code;
+            const isMissingPath = code === "ENOENT";
+            if (isMissingPath) {
+                this.sessionLogger.warn({ err: error, cwd, path: requestedPath }, `Workspace offline for file explorer request: ${cwd}`);
+            }
+            else {
+                this.sessionLogger.error({ err: error, cwd, path: requestedPath }, `Failed to fulfill file explorer request for workspace ${cwd}`);
+            }
             this.emit({
                 type: "file_explorer_response",
                 payload: {
@@ -4490,7 +5029,8 @@ export class Session {
             placementByCwd.set(cwd, placementPromise);
             return placementPromise;
         };
-        let candidates = [...agents];
+        const includeArchived = filter?.includeArchived ?? false;
+        let candidates = includeArchived ? [...agents] : agents.filter((a) => !a.archivedAt);
         candidates.sort((left, right) => this.compareFetchAgentsAgents(left, right, sort));
         const cursorToken = request.page?.cursor;
         if (cursorToken) {
@@ -4552,6 +5092,19 @@ export class Session {
     }
     async describeWorkspaceRecord(workspace, projectRecord) {
         const resolvedProjectRecord = projectRecord ?? (await this.projectRegistry.get(workspace.projectId));
+        let diffStat = null;
+        const cachedShortstat = getCachedCheckoutShortstat(workspace.cwd);
+        if (cachedShortstat !== undefined) {
+            diffStat = cachedShortstat;
+        }
+        else {
+            const cwd = workspace.cwd;
+            warmCheckoutShortstatInBackground(cwd, undefined, () => {
+                this.emitWorkspaceUpdateForCwd(cwd).catch((error) => {
+                    this.sessionLogger.warn({ error, cwd }, "Failed to emit workspace update after shortstat warm");
+                });
+            });
+        }
         return {
             id: workspace.workspaceId,
             projectId: workspace.projectId,
@@ -4562,7 +5115,7 @@ export class Session {
             name: workspace.displayName,
             status: "done",
             activityAt: null,
-            diffStat: null,
+            diffStat,
         };
     }
     buildWorkspaceGitRuntimePayload(snapshot) {
@@ -4605,7 +5158,10 @@ export class Session {
         return {
             ...base,
             name: displayName,
-            diffStat: snapshot?.git.diffStat ?? null,
+            // Prefer the live git-runtime snapshot, but fall back to the shortstat
+            // cache that describeWorkspaceRecord warmed so the background update is
+            // not discarded when the snapshot has no diffStat yet.
+            diffStat: snapshot?.git.diffStat ?? base.diffStat,
             gitRuntime: snapshot ? this.buildWorkspaceGitRuntimePayload(snapshot) : undefined,
             githubRuntime: snapshot ? this.buildWorkspaceGitHubRuntimePayload(snapshot) : undefined,
         };
@@ -4630,17 +5186,17 @@ export class Session {
         const workspaceIds = options.workspaceIds
             ? new Set(Array.from(options.workspaceIds, (workspaceId) => normalizePersistedWorkspaceId(workspaceId)))
             : null;
-        for (const workspace of activeRecords) {
-            if (workspaceIds && !workspaceIds.has(workspace.workspaceId)) {
-                continue;
-            }
+        const filteredRecords = workspaceIds
+            ? activeRecords.filter((workspace) => workspaceIds.has(workspace.workspaceId))
+            : activeRecords;
+        await Promise.all(filteredRecords.map(async (workspace) => {
             const projectRecord = activeProjects.get(workspace.projectId) ?? null;
             descriptorsByWorkspaceId.set(workspace.workspaceId, await this.buildWorkspaceDescriptor({
                 workspace,
                 projectRecord,
                 includeGitData: options.includeGitData,
             }));
-        }
+        }));
         for (const agent of agents) {
             if (agent.archivedAt) {
                 continue;
@@ -4891,7 +5447,6 @@ export class Session {
             buildPersistedWorkspaceRecord: (input) => this.buildPersistedWorkspaceRecord(input),
             buildProjectPlacement: (cwd) => this.buildProjectPlacement(cwd),
             projectRegistry: this.projectRegistry,
-            syncWorkspaceGitWatchTarget: (cwd, syncOptions) => this.syncWorkspaceGitWatchTarget(cwd, syncOptions),
             workspaceRegistry: this.workspaceRegistry,
             archiveProjectRecordIfEmpty: (projectId, archivedAt) => this.archiveProjectRecordIfEmpty(projectId, archivedAt),
         }, options);
@@ -4910,6 +5465,46 @@ export class Session {
             await this.projectRegistry.archive(existing.projectId, nextArchivedAt);
         }
     }
+    async findWorkspaceRecordForRequest(workspaceId) {
+        const normalizedWorkspaceId = normalizePersistedWorkspaceId(workspaceId);
+        const normalized = await this.workspaceRegistry.get(normalizedWorkspaceId);
+        if (normalized) {
+            return normalized;
+        }
+        if (normalizedWorkspaceId !== workspaceId) {
+            const raw = await this.workspaceRegistry.get(workspaceId);
+            if (raw) {
+                return raw;
+            }
+        }
+        const lookupKey = normalizeWorkspaceLookupKey(workspaceId);
+        const records = await this.workspaceRegistry.list();
+        return (records.find((record) => normalizeWorkspaceLookupKey(record.workspaceId) === lookupKey) ??
+            null);
+    }
+    emitWorkspaceRemoveForId(workspaceId) {
+        const subscription = this.workspaceUpdatesSubscription;
+        const id = workspaceId.trim();
+        if (!subscription || !id) {
+            return;
+        }
+        this.bufferOrEmitWorkspaceUpdate(subscription, {
+            kind: "remove",
+            id,
+        });
+    }
+    emitWorkspaceRemoveAliasesForRequest(requestedWorkspaceId, persistedWorkspaceId) {
+        this.emitWorkspaceRemoveForId(persistedWorkspaceId);
+        const requested = requestedWorkspaceId.trim();
+        if (!requested || requested === persistedWorkspaceId) {
+            return;
+        }
+        if (normalizeWorkspaceLookupKey(requestedWorkspaceId) !==
+            normalizeWorkspaceLookupKey(persistedWorkspaceId)) {
+            return;
+        }
+        this.emitWorkspaceRemoveForId(requested);
+    }
     async reconcileAndEmitWorkspaceUpdates() {
         if (!this.workspaceUpdatesSubscription) {
             return;
@@ -5125,8 +5720,30 @@ export class Session {
             });
         }
     }
+    async resolveAvailableEditorTargets() {
+        return listAvailableEditorTargets();
+    }
+    async getMemoizedAvailableEditorTargets() {
+        const cached = this.availableEditorTargetsCache.get(AVAILABLE_EDITOR_TARGETS_CACHE_KEY);
+        if (cached) {
+            return cached;
+        }
+        if (this.availableEditorTargetsInflight) {
+            return this.availableEditorTargetsInflight;
+        }
+        const inflight = this.resolveAvailableEditorTargets()
+            .then((editors) => {
+            this.availableEditorTargetsCache.set(AVAILABLE_EDITOR_TARGETS_CACHE_KEY, editors);
+            return editors;
+        })
+            .finally(() => {
+            this.availableEditorTargetsInflight = null;
+        });
+        this.availableEditorTargetsInflight = inflight;
+        return inflight;
+    }
     async getAvailableEditorTargets() {
-        return this.filterEditorsForClient(await listAvailableEditorTargets());
+        return this.filterEditorsForClient(await this.getMemoizedAvailableEditorTargets());
     }
     async openEditorTarget(options) {
         await openInEditorTarget(options);
@@ -5194,6 +5811,7 @@ export class Session {
             describeWorkspaceRecord: (workspace) => this.describeWorkspaceRecordWithGitData(workspace),
             emit: (message) => this.emit(message),
             registerPendingWorktreeWorkspace: (options) => this.registerPendingWorktreeWorkspace(options),
+            syncWorkspaceGitWatchTarget: (cwd, syncOptions) => this.syncWorkspaceGitWatchTarget(cwd, syncOptions),
             sessionLogger: this.sessionLogger,
             createSeaworkWorktreeInBackground: (options) => this.createSeaworkWorktreeInBackground(options),
         }, request);
@@ -5320,14 +5938,27 @@ export class Session {
     }
     async handleArchiveWorkspaceRequest(request) {
         try {
-            const existing = await this.workspaceRegistry.get(request.workspaceId);
-            if (!existing || existing.archivedAt) {
+            const existing = await this.findWorkspaceRecordForRequest(request.workspaceId);
+            if (!existing) {
                 this.emit({
                     type: "archive_workspace_response",
                     payload: {
                         requestId: request.requestId,
                         workspaceId: request.workspaceId,
-                        archivedAt: existing?.archivedAt ?? null,
+                        archivedAt: null,
+                        error: null,
+                    },
+                });
+                return;
+            }
+            if (existing.archivedAt) {
+                this.emitWorkspaceRemoveAliasesForRequest(request.workspaceId, existing.workspaceId);
+                this.emit({
+                    type: "archive_workspace_response",
+                    payload: {
+                        requestId: request.requestId,
+                        workspaceId: request.workspaceId,
+                        archivedAt: existing.archivedAt,
                         error: null,
                     },
                 });
@@ -5337,8 +5968,8 @@ export class Session {
                 throw new Error("Use worktree archive for Seawork worktrees");
             }
             const archivedAt = new Date().toISOString();
-            await this.archiveWorkspaceRecord(request.workspaceId, archivedAt);
-            await this.emitWorkspaceUpdatesForWorkspaceIds([request.workspaceId]);
+            await this.archiveWorkspaceRecord(existing.workspaceId, archivedAt);
+            this.emitWorkspaceRemoveAliasesForRequest(request.workspaceId, existing.workspaceId);
             this.emit({
                 type: "archive_workspace_response",
                 payload: {
@@ -5397,7 +6028,7 @@ export class Session {
         const requestedLimit = msg.limit;
         const limit = requestedLimit ?? (direction === "after" ? 0 : undefined);
         const shouldLimitByProjectedWindow = projection === "canonical" &&
-            direction === "tail" &&
+            (direction === "tail" || direction === "before") &&
             typeof requestedLimit === "number" &&
             requestedLimit > 0;
         const cursor = msg.cursor
@@ -5433,13 +6064,17 @@ export class Session {
                 });
                 while (timeline.hasOlder) {
                     const needsMoreProjectedEntries = projectedWindow.projectedEntries.length < projectedLimit;
-                    const firstLoadedRow = timeline.rows[0];
-                    const firstSelectedRow = projectedWindow.selectedRows[0];
-                    const startsAtLoadedBoundary = firstLoadedRow != null &&
-                        firstSelectedRow != null &&
-                        firstSelectedRow.seq === firstLoadedRow.seq;
-                    const boundaryIsAssistantChunk = startsAtLoadedBoundary && firstLoadedRow.item.type === "assistant_message";
-                    if (!needsMoreProjectedEntries && !boundaryIsAssistantChunk) {
+                    // Both tail and before select the newest projected entries within the
+                    // loaded window, so a canonical-limit cut can only land at the OLDEST
+                    // end (rows[0]); the newest end abuts the cursor and is chunk-safe.
+                    const oldestLoadedRow = timeline.rows[0];
+                    const oldestSelectedRow = projectedWindow.selectedRows[0];
+                    const selectedStartsAtOldestLoadedBoundary = oldestLoadedRow != null &&
+                        oldestSelectedRow != null &&
+                        oldestSelectedRow.seq === oldestLoadedRow.seq;
+                    const oldestBoundaryIsAssistantChunk = selectedStartsAtOldestLoadedBoundary &&
+                        oldestLoadedRow.item.type === "assistant_message";
+                    if (!needsMoreProjectedEntries && !oldestBoundaryIsAssistantChunk) {
                         break;
                     }
                     const maxRows = Math.max(0, timeline.window.maxSeq - timeline.window.minSeq + 1);
@@ -5462,12 +6097,16 @@ export class Session {
                     });
                 }
                 const selectedRows = projectedWindow.selectedRows;
-                entries = projectTimelineRows(selectedRows, snapshot.provider, projection);
+                entries = projectTimelineRows(selectedRows, snapshot.provider, projection, {
+                    ...legacyTimelineProjectionOptions(this.appVersion),
+                });
                 if (projectedWindow.minSeq !== null && projectedWindow.maxSeq !== null) {
                     startCursor = { epoch: timeline.epoch, seq: projectedWindow.minSeq };
                     endCursor = { epoch: timeline.epoch, seq: projectedWindow.maxSeq };
                     hasOlder = projectedWindow.minSeq > timeline.window.minSeq;
-                    hasNewer = false;
+                    // For tail this is always false (the window IS the newest rows); for
+                    // before it is true whenever newer rows remain above the page.
+                    hasNewer = projectedWindow.maxSeq < timeline.window.maxSeq;
                 }
             }
             else {
@@ -5475,7 +6114,9 @@ export class Session {
                 const lastRow = timeline.rows[timeline.rows.length - 1];
                 startCursor = firstRow ? { epoch: timeline.epoch, seq: firstRow.seq } : null;
                 endCursor = lastRow ? { epoch: timeline.epoch, seq: lastRow.seq } : null;
-                entries = projectTimelineRows(timeline.rows, snapshot.provider, projection);
+                entries = projectTimelineRows(timeline.rows, snapshot.provider, projection, {
+                    ...legacyTimelineProjectionOptions(this.appVersion),
+                });
             }
             this.emit({
                 type: "fetch_agent_timeline_response",
@@ -5500,7 +6141,62 @@ export class Session {
             });
         }
         catch (error) {
-            this.sessionLogger.error({ err: error, agentId: msg.agentId }, "Failed to handle fetch_agent_timeline_request");
+            // Workspaces on external/removable drives can vanish between sessions;
+            // this is a known/expected condition for resume requests and shouldn't
+            // pollute the daemon log at ERROR. See issue #662 / #632.
+            const message = error instanceof Error ? error.message : String(error);
+            const isMissingCwd = /Working directory does not exist/.test(message);
+            let offlineTimeline = null;
+            try {
+                offlineTimeline = await this.loadOfflineTimelineForStoredAgent({
+                    agentId: msg.agentId,
+                    direction,
+                    cursor,
+                    limit: shouldLimitByProjectedWindow && typeof requestedLimit === "number" ? 0 : limit,
+                });
+            }
+            catch (offlineError) {
+                this.sessionLogger.warn({ err: offlineError, agentId: msg.agentId }, "Failed to load offline persisted agent timeline");
+            }
+            if (offlineTimeline) {
+                const projected = projectOfflineTimelineFetchResponse({
+                    model: offlineTimeline.model,
+                    direction,
+                    projection,
+                    shouldLimitByProjectedWindow,
+                    requestedLimit,
+                    projectionOptions: legacyTimelineProjectionOptions(this.appVersion),
+                });
+                this.sessionLogger.warn({ err: error, agentId: msg.agentId, provider: offlineTimeline.model.agentProvider }, "Loaded persisted agent timeline without resuming provider session");
+                this.emit({
+                    type: "fetch_agent_timeline_response",
+                    payload: {
+                        requestId: msg.requestId,
+                        agentId: msg.agentId,
+                        agent: this.buildStoredAgentPayload(offlineTimeline.record),
+                        direction,
+                        projection,
+                        epoch: offlineTimeline.model.epoch,
+                        reset: offlineTimeline.model.reset,
+                        staleCursor: offlineTimeline.model.staleCursor,
+                        gap: offlineTimeline.model.gap,
+                        window: offlineTimeline.model.window,
+                        startCursor: projected.startCursor,
+                        endCursor: projected.endCursor,
+                        hasOlder: projected.hasOlder,
+                        hasNewer: projected.hasNewer,
+                        entries: projected.entries,
+                        error: null,
+                    },
+                });
+                return;
+            }
+            if (isMissingCwd) {
+                this.sessionLogger.warn({ err: error, agentId: msg.agentId }, "Workspace offline while loading agent timeline");
+            }
+            else {
+                this.sessionLogger.error({ err: error, agentId: msg.agentId }, "Failed to handle fetch_agent_timeline_request");
+            }
             this.emit({
                 type: "fetch_agent_timeline_response",
                 payload: {
@@ -5555,6 +6251,7 @@ export class Session {
             try {
                 this.agentManager.recordUserMessage(agentId, msg.text, {
                     messageId: msg.messageId,
+                    images: msg.imageAttachments,
                     emitState: false,
                 });
             }
@@ -5562,6 +6259,22 @@ export class Session {
                 this.sessionLogger.error({ err: error, agentId }, "Failed to record user message for send_agent_message_request");
             }
             const prompt = this.buildAgentPrompt(msg.text, msg.images, msg.documents);
+            if (typeof prompt === "string") {
+                const oob = await this.agentManager.tryRunOutOfBand(agentId, prompt);
+                if (oob) {
+                    await this.agentManager.appendTimelineItem(agentId, {
+                        type: "assistant_message",
+                        text: oob.response,
+                    });
+                    this.agentManager.emitAgentState(agentId);
+                    latencyTracker.dropPending(agentId);
+                    this.emit({
+                        type: "send_agent_message_response",
+                        payload: { requestId: msg.requestId, agentId, accepted: true, error: null },
+                    });
+                    return;
+                }
+            }
             this.sessionLogger.info({
                 agentId,
                 messageId: msg.messageId,
@@ -6609,6 +7322,38 @@ export class Session {
             this.emitScheduleRpcError(request, error);
         }
     }
+    async handleScheduleUpdateRequest(request) {
+        try {
+            const schedule = await this.scheduleService.update(request.scheduleId, request.patch);
+            this.emit({
+                type: "schedule/update/response",
+                payload: {
+                    requestId: request.requestId,
+                    schedule: this.toScheduleSummary(schedule),
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    async handleScheduleRunNowRequest(request) {
+        try {
+            const run = await this.scheduleService.triggerNow(request.scheduleId);
+            this.emit({
+                type: "schedule/run-now/response",
+                payload: {
+                    requestId: request.requestId,
+                    run,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
     emitLoopRpcError(request, error) {
         const message = error instanceof Error ? error.message : String(error);
         this.sessionLogger.error({ err: error, requestType: request.type }, "Loop request failed");
@@ -7137,4 +7882,72 @@ export class Session {
 // Stash handlers
 // ---------------------------------------------------------------------------
 Session.SEAWORK_STASH_PREFIX = "seawork-auto-stash:";
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return "Unknown error";
+}
+function normalizeNonEmptyStrings(values) {
+    return (values ?? []).map((value) => value.trim()).filter(Boolean);
+}
+function mergeUniqueNonEmptyStrings(current, incoming) {
+    return [
+        ...new Set([...normalizeNonEmptyStrings(current), ...normalizeNonEmptyStrings(incoming)]),
+    ];
+}
+function rehydratePatchWeComOpenClawSecret(input) {
+    const incoming = input.patch.integrations?.wecomOpenClaw;
+    if (!incoming || incoming.secret !== PROVIDER_ENV_VALUE_REDACTED) {
+        return input.patch;
+    }
+    const currentSecret = input.current.integrations?.wecomOpenClaw?.secret;
+    if (!currentSecret) {
+        return input.patch;
+    }
+    return {
+        ...input.patch,
+        integrations: {
+            ...input.patch.integrations,
+            wecomOpenClaw: {
+                ...incoming,
+                secret: currentSecret,
+            },
+        },
+    };
+}
+function resolvePatchWeComOpenClawAgentCwd(input) {
+    const incoming = input.patch.integrations?.wecomOpenClaw;
+    if (!incoming || incoming.cwd === undefined) {
+        return input.patch;
+    }
+    return {
+        ...input.patch,
+        integrations: {
+            ...input.patch.integrations,
+            wecomOpenClaw: {
+                ...incoming,
+                cwd: resolveWeComOpenClawAgentCwd(incoming.cwd, input.seaworkHome),
+            },
+        },
+    };
+}
+// Normalize per-project cwds (tilde-expand + path.resolve) at storage time so
+// they match the agent's already-expanded cwd in resolvePromptInjection.
+function resolvePatchPromptInjectionCwds(patch) {
+    const projects = patch.promptInjection?.projects;
+    if (!projects) {
+        return patch;
+    }
+    return {
+        ...patch,
+        promptInjection: {
+            ...patch.promptInjection,
+            projects: projects.map((p) => ({ ...p, cwd: resolve(expandTilde(p.cwd)) })),
+        },
+    };
+}
 //# sourceMappingURL=session.js.map