@nordbyte/nordrelay 0.5.1 → 0.6.0

package/dist/relay-runtime.js

@@ -2,31 +2,40 @@ import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { ensureOutDir } from "./artifacts.js";
 import { buildFileInstructions, outboxPath, stageFile, } from "./attachments.js";
-import { CODEX_AGENT_CAPABILITIES, agentLabel, agentReasoningLabel, agentReasoningOptions, } from "./agent.js";
+import { CODEX_AGENT_CAPABILITIES, agentLabel, agentReasoningLabel, agentReasoningOptions, isAgentId, } from "./agent.js";
 import { getAgentDiagnostics, getExternalSnapshotForSession, } from "./agent-activity.js";
 import { listAgentAdapterDescriptors } from "./agent-adapter.js";
 import { AgentUpdateManager } from "./agent-updates.js";
 import { createAgentSessionService, enabledAgents } from "./agent-factory.js";
 import { AuditLogStore } from "./audit-log.js";
+import { BotPreferencesStore } from "./bot-preferences.js";
+import { ChannelTurnService } from "./channel-turn-service.js";
 import { checkAuthStatus, startLogin as startCodexLogin, startLogout as startCodexLogout } from "./codex-auth.js";
 import { checkClaudeCodeAuthStatus, startClaudeCodeLogin, startClaudeCodeLogout } from "./claude-code-auth.js";
+import { listThreads as listCodexThreads } from "./codex-state.js";
 import { friendlyErrorText } from "./error-messages.js";
 import { checkHermesAuthStatus, startHermesLogin, startHermesLogout } from "./hermes-auth.js";
 import { checkOpenClawAuthStatus } from "./openclaw-auth.js";
 import { clearLogFile, getAgentUpdateLogPath, getConnectorHealth, getConnectorLogPath, getPackageVersion, getUpdateLogPath, getVersionChecks, readConnectorState, readFormattedLogTail, spawnConnectorRestart, spawnSelfUpdate } from "./operations.js";
 import { checkPiAuthStatus } from "./pi-auth.js";
 import { PromptStore, toPromptEnvelope } from "./prompt-store.js";
+import { UnifiedJobStore } from "./job-store.js";
+import { buildRuntimeMetrics } from "./metrics.js";
 import { RelayArtifactService } from "./relay-artifact-service.js";
 import { RelayExternalActivityMonitor } from "./relay-external-activity-monitor.js";
 import { RelayQueueService } from "./relay-queue-service.js";
+import { RuntimeSnapshotCache } from "./runtime-cache.js";
 import { renderSessionInfoPlain, renderSessionUsageRows } from "./session-format.js";
 import { SessionLockStore } from "./session-locks.js";
 import { SessionRegistry } from "./session-registry.js";
 import { createSupportBundle } from "./support-bundle.js";
 import { transcribeAudio } from "./voice.js";
 import { WebActivityStore, WebChatStore, } from "./web-state.js";
+import { channelIdForContextKey } from "./context-key.js";
 import { evaluateWorkspacePolicy, filterAllowedWorkspaces } from "./workspace-policy.js";
 const WEB_CONTEXT_KEY = "web:dashboard";
+const ACTIVE_CODEX_DISCOVERY_LIMIT = 200;
+const ACTIVE_ACTIVITY_TTL_MS = 6 * 60 * 60 * 1000;
 const MAX_WEB_SESSION_PAGE_SIZE = 50;
 const MAX_CHAT_HISTORY = 250;
 export class RelayRuntime {
@@ -39,9 +48,14 @@ export class RelayRuntime {
     lockStore;
     agentUpdates;
     queueService;
+    jobStore;
     artifactService;
     externalActivityMonitor;
+    cache = new RuntimeSnapshotCache();
+    turnService;
     subscribers = new Set();
+    agentUpdateActors = new Map();
+    agentUpdateStates = new Map();
     externalMonitor;
     draining = false;
     currentTurnId = null;
@@ -60,9 +74,13 @@ export class RelayRuntime {
         this.auditStore = new AuditLogStore(config.workspace, config.stateBackend, config.auditMaxEvents);
         this.lockStore = new SessionLockStore(config.workspace, config.stateBackend);
         this.queueService = new RelayQueueService(this.promptStore, WEB_CONTEXT_KEY);
+        this.jobStore = new UnifiedJobStore(config.workspace, config.stateBackend, config.unifiedJobMaxItems);
         this.artifactService = new RelayArtifactService(config);
         this.agentUpdates = new AgentUpdateManager({
-            onUpdate: (job) => this.broadcast({ type: "agent_update", job }),
+            onUpdate: (job) => {
+                this.broadcast({ type: "agent_update", job });
+                this.recordAgentUpdateLifecycle(job);
+            },
         });
         this.externalActivityMonitor = new RelayExternalActivityMonitor({
             config,
@@ -83,6 +101,36 @@ export class RelayRuntime {
             }, config.codexExternalBusyCheckMs);
             this.externalMonitor.unref?.();
         }
+        this.turnService = new ChannelTurnService({
+            source: "web",
+            contextKey: WEB_CONTEXT_KEY,
+            chatStore: this.chatStore,
+            artifactService: this.artifactService,
+            checkAuth: (info) => this.checkAgentAuth(info),
+            ensureActiveThread: (session) => this.ensureActiveThread(session),
+            updateSession: (session) => this.updateSession(session),
+            appendActivity: (input) => this.appendActivity(input),
+            appendAudit: (input) => this.appendAudit(input),
+            broadcast: (event) => this.broadcast(event),
+            chatHistory: () => this.chatHistory(),
+            setLastPrompt: (envelope) => this.queueService.setLastPrompt(envelope),
+            getCurrentProgress: () => this.currentProgress,
+            setCurrentProgress: (progress) => {
+                this.currentProgress = progress;
+            },
+            setCurrentTurn: (id, startedAt, accumulatedText) => {
+                this.currentTurnId = id;
+                if (startedAt !== undefined)
+                    this.currentTurnStartedAt = startedAt;
+                if (accumulatedText !== undefined)
+                    this.accumulatedText = accumulatedText;
+            },
+            getCurrentTurnStartedAt: () => this.currentTurnStartedAt,
+            getAccumulatedText: () => this.accumulatedText,
+            setAccumulatedText: (text) => {
+                this.accumulatedText = text;
+            },
+        });
     }
     subscribe(callback) {
         this.subscribers.add(callback);
@@ -105,10 +153,16 @@ export class RelayRuntime {
         };
     }
     async status() {
+        const cliOptions = this.cliPathOptions();
+        const [health, versionChecks, snapshot] = await Promise.all([
+            getConnectorHealth(cliOptions),
+            getVersionChecks(cliOptions),
+            this.snapshot(),
+        ]);
         return {
-            health: await getConnectorHealth({ piCliPath: this.config.piCliPath, hermesCliPath: this.config.hermesCliPath, openClawCliPath: this.config.openClawCliPath, claudeCodeCliPath: this.config.claudeCodeCliPath }),
-            versionChecks: await getVersionChecks({ piCliPath: this.config.piCliPath, hermesCliPath: this.config.hermesCliPath, openClawCliPath: this.config.openClawCliPath, claudeCodeCliPath: this.config.claudeCodeCliPath }),
-            snapshot: await this.snapshot(),
+            health,
+            versionChecks,
+            snapshot,
         };
     }
     async bootstrapStatus() {
@@ -121,13 +175,22 @@ export class RelayRuntime {
         };
     }
     async version() {
-        return {
-            health: await getConnectorHealth({ piCliPath: this.config.piCliPath, hermesCliPath: this.config.hermesCliPath, openClawCliPath: this.config.openClawCliPath, claudeCodeCliPath: this.config.claudeCodeCliPath }),
-            state: await readConnectorState(),
-            versionChecks: await getVersionChecks({ piCliPath: this.config.piCliPath, hermesCliPath: this.config.hermesCliPath, openClawCliPath: this.config.openClawCliPath, claudeCodeCliPath: this.config.claudeCodeCliPath }),
-        };
+        return this.cached("version", async () => {
+            const cliOptions = this.cliPathOptions();
+            const [health, state, versionChecks] = await Promise.all([
+                getConnectorHealth(cliOptions),
+                readConnectorState(),
+                getVersionChecks(cliOptions),
+            ]);
+            return {
+                health,
+                state,
+                versionChecks,
+            };
+        });
     }
-    updateConnector() {
+    updateConnector(actor) {
+        this.cache.invalidate("version");
         const update = spawnSelfUpdate();
         this.broadcastStatus(`Update started with ${update.method}. Log: ${update.logPath}`, "warn");
         this.appendActivity({
@@ -136,12 +199,14 @@ export class RelayRuntime {
             type: "update_started",
             threadId: null,
             workspace: this.config.workspace,
+            actor,
             detail: `${update.method}: ${update.summary}`,
         });
         this.appendAudit({
             action: "command",
             status: "ok",
             contextKey: WEB_CONTEXT_KEY,
+            actor,
             description: "update",
             detail: update.summary,
         });
@@ -150,13 +215,19 @@ export class RelayRuntime {
     agentUpdateJobs() {
         return this.agentUpdates.list();
     }
-    startAgentUpdate(agentId, operation = "update") {
+    startAgentUpdate(agentId, operation = "update", actor) {
+        this.cache.invalidate("adapterHealth");
+        this.cache.invalidate("version");
         const job = this.agentUpdates.start(agentId, {
             piCliPath: this.config.piCliPath,
             hermesCliPath: this.config.hermesCliPath,
             openClawCliPath: this.config.openClawCliPath,
             claudeCodeCliPath: this.config.claudeCodeCliPath,
         }, operation);
+        if (actor) {
+            this.agentUpdateActors.set(job.id, actor);
+        }
+        this.agentUpdateStates.set(job.id, { status: job.status, needsInput: job.needsInput });
         this.broadcastStatus(`${job.agentLabel} ${operation} started. Log: ${job.logPath}`, "warn");
         this.appendActivity({
             source: "web",
@@ -165,6 +236,7 @@ export class RelayRuntime {
             agentId,
             threadId: null,
             workspace: this.config.workspace,
+            actor,
             detail: `${job.method}: ${job.summary}`,
         });
         this.appendAudit({
@@ -172,6 +244,7 @@ export class RelayRuntime {
             status: "ok",
             contextKey: WEB_CONTEXT_KEY,
             agentId,
+            actor,
             description: `${operation} ${agentId}`,
             detail: job.summary,
         });
@@ -180,83 +253,130 @@ export class RelayRuntime {
     agentUpdateLog(id) {
         return this.agentUpdates.readLog(id);
     }
-    deleteAgentUpdateLog(id) {
+    deleteAgentUpdateLog(id, actor) {
         const job = this.agentUpdates.deleteLog(id);
+        this.appendActivity({
+            source: "web",
+            status: "info",
+            type: "agent_update_log_deleted",
+            agentId: job.agentId,
+            threadId: null,
+            workspace: this.config.workspace,
+            actor,
+            detail: job.logPath,
+        });
         this.appendAudit({
             action: "command",
             status: "ok",
             contextKey: WEB_CONTEXT_KEY,
             agentId: job.agentId,
+            actor,
             description: `delete update log ${id}`,
             detail: job.logPath,
         });
         return job;
     }
-    sendAgentUpdateInput(id, input) {
-        return this.agentUpdates.sendInput(id, input);
+    sendAgentUpdateInput(id, input, actor) {
+        const job = this.agentUpdates.sendInput(id, input);
+        this.appendActivity({
+            source: "web",
+            status: "info",
+            type: "agent_update_input_sent",
+            agentId: job.agentId,
+            threadId: null,
+            workspace: this.config.workspace,
+            actor: actor ?? this.agentUpdateActors.get(id),
+            detail: `Input sent to ${job.agentLabel} ${job.operation}.`,
+        });
+        return job;
     }
-    cancelAgentUpdate(id) {
-        return this.agentUpdates.cancel(id);
+    cancelAgentUpdate(id, actor) {
+        const job = this.agentUpdates.cancel(id);
+        this.appendActivity({
+            source: "web",
+            status: "aborted",
+            type: "agent_update_cancel_requested",
+            agentId: job.agentId,
+            threadId: null,
+            workspace: this.config.workspace,
+            actor: actor ?? this.agentUpdateActors.get(id),
+            detail: `${job.agentLabel} ${job.operation} cancellation requested.`,
+        });
+        return job;
     }
     async diagnostics() {
-        return {
-            health: await getConnectorHealth({ piCliPath: this.config.piCliPath, hermesCliPath: this.config.hermesCliPath, openClawCliPath: this.config.openClawCliPath, claudeCodeCliPath: this.config.claudeCodeCliPath }),
-            versionChecks: await getVersionChecks({ piCliPath: this.config.piCliPath, hermesCliPath: this.config.hermesCliPath, openClawCliPath: this.config.openClawCliPath, claudeCodeCliPath: this.config.claudeCodeCliPath }),
-            snapshot: await this.snapshot(),
-            runtime: {
-                stateBackend: this.config.stateBackend,
-                sourceWorkspace: this.config.workspace,
-                queuePaused: this.queueService.isPaused(),
-                externalMirror: this.externalActivityMonitor.snapshot(),
-                agentDiagnostics: getAgentDiagnostics(await this.getSession(true), this.config),
-            },
-        };
-    }
-    async adapterHealth() {
-        const health = await getConnectorHealth({ piCliPath: this.config.piCliPath, hermesCliPath: this.config.hermesCliPath, openClawCliPath: this.config.openClawCliPath, claudeCodeCliPath: this.config.claudeCodeCliPath });
-        const versions = await getVersionChecks({ piCliPath: this.config.piCliPath, hermesCliPath: this.config.hermesCliPath, openClawCliPath: this.config.openClawCliPath, claudeCodeCliPath: this.config.claudeCodeCliPath });
-        return Promise.all(listAgentAdapterDescriptors().map(async (descriptor) => {
-            const enabled = enabledAgents(this.config).includes(descriptor.id);
-            const auth = descriptor.capabilities.auth && enabled
-                ? await this.authStatus(descriptor.id).catch((error) => ({
-                    agentId: descriptor.id,
-                    agentLabel: descriptor.label,
-                    supported: descriptor.capabilities.auth,
-                    authenticated: false,
-                    detail: friendlyErrorText(error),
-                    loginSupported: descriptor.capabilities.login,
-                    logoutSupported: descriptor.capabilities.logout,
-                }))
-                : null;
-            const cli = cliHealthForAgent(descriptor.id, health);
-            const version = versionCheckForAgent(descriptor.id, versions);
+        return this.cached("diagnostics", async () => {
+            const cliOptions = this.cliPathOptions();
+            const [health, versionChecks, snapshot, session] = await Promise.all([
+                getConnectorHealth(cliOptions),
+                getVersionChecks(cliOptions),
+                this.snapshot(),
+                this.getSession(true),
+            ]);
             return {
-                id: descriptor.id,
-                label: descriptor.label,
-                enabled,
-                status: descriptor.status === "available" ? (enabled ? "enabled" : "disabled") : "planned",
-                auth: {
-                    supported: descriptor.capabilities.auth,
-                    authenticated: auth ? auth.authenticated : null,
-                    method: auth?.method,
-                    detail: auth?.detail,
+                health,
+                versionChecks,
+                snapshot,
+                runtime: {
+                    stateBackend: this.config.stateBackend,
+                    sourceWorkspace: this.config.workspace,
+                    queuePaused: this.queueService.isPaused(),
+                    externalMirror: this.externalActivityMonitor.snapshot(),
+                    agentDiagnostics: getAgentDiagnostics(session, this.config),
                 },
-                cli,
-                version: {
-                    installed: version.installedLabel,
-                    latest: version.latestVersion,
-                    status: version.status,
-                    detail: version.detail,
-                },
-                capabilities: descriptor.capabilities,
-                notes: descriptor.notes,
             };
-        }));
+        });
+    }
+    async adapterHealth() {
+        return this.cached("adapterHealth", async () => {
+            const cliOptions = this.cliPathOptions();
+            const [health, versions] = await Promise.all([
+                getConnectorHealth(cliOptions),
+                getVersionChecks(cliOptions),
+            ]);
+            return Promise.all(listAgentAdapterDescriptors().map(async (descriptor) => {
+                const enabled = enabledAgents(this.config).includes(descriptor.id);
+                const auth = descriptor.capabilities.auth && enabled
+                    ? await this.authStatus(descriptor.id).catch((error) => ({
+                        agentId: descriptor.id,
+                        agentLabel: descriptor.label,
+                        supported: descriptor.capabilities.auth,
+                        authenticated: false,
+                        detail: friendlyErrorText(error),
+                        loginSupported: descriptor.capabilities.login,
+                        logoutSupported: descriptor.capabilities.logout,
+                    }))
+                    : null;
+                const cli = cliHealthForAgent(descriptor.id, health);
+                const version = versionCheckForAgent(descriptor.id, versions);
+                return {
+                    id: descriptor.id,
+                    label: descriptor.label,
+                    enabled,
+                    status: descriptor.status === "available" ? (enabled ? "enabled" : "disabled") : "planned",
+                    auth: {
+                        supported: descriptor.capabilities.auth,
+                        authenticated: auth ? auth.authenticated : null,
+                        method: auth?.method,
+                        detail: auth?.detail,
+                    },
+                    cli,
+                    version: {
+                        installed: version.installedLabel,
+                        latest: version.latestVersion,
+                        status: version.status,
+                        detail: version.detail,
+                    },
+                    capabilities: descriptor.capabilities,
+                    notes: descriptor.notes,
+                };
+            }));
+        });
     }
     permissions() {
         return {
             mode: "users",
-            message: "Access is managed by NordRelay users, groups, Telegram identities, and Telegram chat access records.",
+            message: "Access is managed by NordRelay users, groups, Telegram identities, Telegram chat access records, Discord identities, and Discord channel access records.",
         };
     }
     tasks() {
@@ -268,10 +388,229 @@ export class RelayRuntime {
             recent: this.activity({ limit: 20 }),
         };
     }
-    audit(limit = 50) {
-        return this.auditStore.list(limit);
+    async jobs() {
+        const jobs = [];
+        const current = this.currentProgress;
+        if (current) {
+            jobs.push(taskToUnifiedJob("web:current", "web-turn", "Current WebUI turn", current, {
+                canCancel: current.status === "running",
+                canRetry: false,
+                canReadLog: false,
+            }));
+        }
+        const external = this.externalActivityMonitor.task();
+        if (external) {
+            jobs.push(taskToUnifiedJob(`external:${external.agentId ?? "agent"}:${external.threadId ?? "pending"}`, "external-turn", "External CLI turn", external, {
+                canCancel: false,
+                canRetry: false,
+                canReadLog: false,
+            }));
+        }
+        for (const item of this.queueService.rawList()) {
+            const createdAt = new Date(item.createdAt).toISOString();
+            jobs.push({
+                id: `queue:${item.id}`,
+                kind: "queued-prompt",
+                title: `Queued prompt ${item.id}`,
+                status: "queued",
+                source: "web",
+                threadId: null,
+                workspace: this.config.workspace,
+                owner: item.activityActor,
+                startedAt: createdAt,
+                updatedAt: createdAt,
+                summary: item.description,
+                queueId: item.id,
+                logTail: item.lastError,
+                canCancel: true,
+                canRetry: true,
+                canReadLog: true,
+            });
+        }
+        for (const job of this.agentUpdates.list()) {
+            jobs.push({
+                id: `agent-update:${job.id}`,
+                kind: "agent-update",
+                title: `${job.agentLabel} ${job.operation}`,
+                status: agentUpdateStatusToUnified(job.status),
+                source: "web",
+                agentId: job.agentId,
+                agentLabel: job.agentLabel,
+                threadId: null,
+                workspace: this.config.workspace,
+                owner: this.agentUpdateActors.get(job.id),
+                startedAt: job.startedAt,
+                updatedAt: job.updatedAt,
+                finishedAt: job.finishedAt,
+                summary: job.error || job.summary,
+                logPath: job.logPath,
+                logTail: job.outputTail,
+                updateJobId: job.id,
+                canCancel: job.status === "running",
+                canRetry: job.status !== "running",
+                canReadLog: true,
+            });
+        }
+        for (const event of this.activity({ limit: 100 })) {
+            if (event.type === "diagnostics_bundle_exported") {
+                jobs.push(activityToUnifiedJob(event, "support-bundle", "Diagnostics support bundle", {
+                    canCancel: false,
+                    canRetry: true,
+                    canReadLog: Boolean(event.detail),
+                }));
+            }
+            else if (event.type === "update_started") {
+                jobs.push(activityToUnifiedJob(event, "connector-update", "NordRelay update", {
+                    canCancel: false,
+                    canRetry: true,
+                    canReadLog: Boolean(event.detail),
+                }));
+            }
+            else if (event.category === "prompt" && event.type.startsWith("prompt_")) {
+                jobs.push(promptActivityToUnifiedJob(event));
+            }
+        }
+        const liveJobs = dedupeJobs(jobs);
+        const storedJobs = this.jobStore.upsertMany(liveJobs);
+        return {
+            jobs: dedupeJobs([...liveJobs, ...storedJobs]).sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt)),
+            updatedAt: new Date().toISOString(),
+        };
     }
-    async supportBundle() {
+    async jobLog(id) {
+        if (id.startsWith("agent-update:")) {
+            const updateId = id.slice("agent-update:".length);
+            const log = this.agentUpdates.readLog(updateId);
+            return { job: (await this.jobs()).jobs.find((job) => job.id === id) ?? null, plain: log.plain };
+        }
+        if (id.startsWith("queue:")) {
+            const queueId = id.slice("queue:".length);
+            const item = this.queueService.rawList().find((candidate) => candidate.id === queueId);
+            return {
+                job: (await this.jobs()).jobs.find((job) => job.id === id) ?? null,
+                plain: item ? [
+                    `Queued prompt: ${item.id}`,
+                    `Created: ${new Date(item.createdAt).toISOString()}`,
+                    `Attempts: ${item.attempts ?? 0}`,
+                    `Description: ${item.description}`,
+                    item.lastError ? `Last error: ${item.lastError}` : "",
+                ].filter(Boolean).join("\n") : "Queued prompt not found.",
+            };
+        }
+        const job = (await this.jobs()).jobs.find((candidate) => candidate.id === id) ?? null;
+        return { job, plain: job?.logTail || job?.logPath || job?.summary || this.jobStore.get(id)?.summary || "No log available for this job." };
+    }
+    async jobAction(id, action, actor) {
+        if (id === "web:current" && action === "cancel") {
+            await this.abort(actor);
+            return this.jobs();
+        }
+        if (id.startsWith("queue:")) {
+            const queueId = id.slice("queue:".length);
+            this.queueService.apply(action === "cancel" ? "cancel" : "run", queueId);
+            this.jobStore.patch(id, {
+                status: action === "cancel" ? "aborted" : "queued",
+                summary: action === "cancel" ? `Cancelled queued prompt ${queueId}.` : `Queued prompt ${queueId} moved to the front.`,
+                canCancel: action !== "cancel",
+                canRetry: action === "cancel",
+                finishedAt: action === "cancel" ? new Date().toISOString() : undefined,
+            });
+            this.broadcast({ type: "queue_update", queue: this.queue(), paused: this.queuePaused() });
+            this.appendActivity({
+                source: "web",
+                status: action === "cancel" ? "aborted" : "queued",
+                type: action === "cancel" ? "job_cancelled" : "job_retried",
+                threadId: null,
+                workspace: this.config.workspace,
+                actor,
+                detail: `queue:${queueId}`,
+            });
+            if (action === "retry") {
+                void this.drainQueue();
+            }
+            return this.jobs();
+        }
+        if (id.startsWith("agent-update:")) {
+            const updateId = id.slice("agent-update:".length);
+            const current = this.agentUpdates.get(updateId);
+            if (!current) {
+                throw new Error("Unknown agent update job.");
+            }
+            if (action === "cancel") {
+                this.cancelAgentUpdate(updateId, actor);
+            }
+            else {
+                this.startAgentUpdate(current.agentId, current.operation, actor);
+            }
+            return this.jobs();
+        }
+        if (id.startsWith("support-bundle:") && action === "retry") {
+            await this.supportBundle(actor);
+            return this.jobs();
+        }
+        if (id.startsWith("connector-update:") && action === "retry") {
+            this.updateConnector(actor);
+            return this.jobs();
+        }
+        throw new Error(`Unsupported job action: ${action} ${id}`);
+    }
+    async activeSessions() {
+        const sessions = new Map();
+        const knownContexts = this.listKnownContextMetadata();
+        const preferences = new BotPreferencesStore(this.config.workspace, this.config.stateBackend);
+        const addActiveSession = (session) => {
+            const key = this.activeSessionKey(session);
+            const existing = sessions.get(key);
+            sessions.set(key, this.preferredActiveSession(existing, session));
+        };
+        if (this.currentProgress?.status === "running") {
+            addActiveSession({
+                ...this.currentProgress,
+                contextKey: WEB_CONTEXT_KEY,
+                sourceContextKey: WEB_CONTEXT_KEY,
+                source: "web",
+                status: "running",
+                queueLength: this.queueService.length(),
+                queuePaused: this.queueService.isPaused(),
+            });
+        }
+        for (const active of this.discoverRunningConnectorSessions()) {
+            addActiveSession(active);
+        }
+        for (const active of this.discoverActiveCodexSessions(knownContexts, preferences)) {
+            addActiveSession(active);
+        }
+        for (const meta of knownContexts) {
+            if (meta.contextKey === WEB_CONTEXT_KEY && this.currentProgress?.status === "running") {
+                continue;
+            }
+            const active = this.externalActiveSession(meta, knownContexts, preferences);
+            if (active) {
+                addActiveSession(active);
+            }
+        }
+        return {
+            sessions: [...sessions.values()].sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt)),
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    async metrics() {
+        const [active, jobs] = await Promise.all([
+            this.activeSessions(),
+            this.jobs(),
+        ]);
+        return buildRuntimeMetrics({
+            queueLength: this.queueService.length(),
+            queuePaused: this.queueService.isPaused(),
+            activeTurnCount: active.sessions.length,
+            jobs: jobs.jobs,
+            activity: this.activity({ limit: 500 }),
+        });
+    }
+    audit(options = 50) {
+        return this.auditStore.list(options);
+    }
+    async supportBundle(actor) {
         const bundle = await createSupportBundle({
             config: this.config,
             diagnostics: await this.diagnostics(),
@@ -286,12 +625,14 @@ export class RelayRuntime {
             type: "diagnostics_bundle_exported",
             threadId: null,
             workspace: this.config.workspace,
+            actor,
             detail: bundle.path,
         });
         this.appendAudit({
             action: "command",
             status: "ok",
             contextKey: WEB_CONTEXT_KEY,
+            actor,
             description: "export diagnostics bundle",
             detail: bundle.path,
         });
@@ -300,23 +641,48 @@ export class RelayRuntime {
     locks() {
         return this.lockStore.list();
     }
-    lockWebSession(ownerName = "Web dashboard") {
-        const lock = this.lockStore.set(WEB_CONTEXT_KEY, 0, ownerName, this.config.sessionLockTtlMs);
+    lockWebSession(ownerName = "Web dashboard", actor) {
+        const label = ownerName || actor?.label || "Web dashboard";
+        const lock = this.lockStore.set(WEB_CONTEXT_KEY, {
+            userId: actor?.id ?? "web",
+            label,
+            channel: "web",
+        }, this.config.sessionLockTtlMs);
+        this.appendActivity({
+            source: "web",
+            status: "info",
+            type: "lock_created",
+            threadId: null,
+            workspace: this.config.workspace,
+            actor,
+            detail: `locked by ${label}`,
+        });
         this.appendAudit({
             action: "lock_updated",
             status: "ok",
             contextKey: WEB_CONTEXT_KEY,
+            actor,
             description: "lock",
-            detail: `locked by ${ownerName}`,
+            detail: `locked by ${label}`,
         });
         return lock;
     }
-    unlockWebSession() {
+    unlockWebSession(actor) {
         const removed = this.lockStore.clear(WEB_CONTEXT_KEY);
+        this.appendActivity({
+            source: "web",
+            status: "info",
+            type: "lock_removed",
+            threadId: null,
+            workspace: this.config.workspace,
+            actor,
+            detail: removed ? "unlocked" : "no lock",
+        });
         this.appendAudit({
             action: "lock_updated",
             status: "ok",
             contextKey: WEB_CONTEXT_KEY,
+            actor,
             description: "unlock",
             detail: removed ? "unlocked" : "no lock",
         });
@@ -385,7 +751,7 @@ export class RelayRuntime {
             }
         }
     }
-    async login(agentId) {
+    async login(agentId, actor) {
         const { session, dispose } = await this.getControlSession(agentId);
         try {
             const info = this.publicInfo(session);
@@ -409,6 +775,16 @@ export class RelayRuntime {
                 };
             }
             const result = await this.startAgentLogin(info);
+            this.appendActivity({
+                source: "web",
+                status: result.success ? "info" : "failed",
+                type: result.success ? "login_started" : "login_failed",
+                threadId: info.threadId,
+                workspace: info.workspace,
+                agentId: info.agentId,
+                actor,
+                detail: result.message,
+            });
             this.appendAudit({
                 action: "command",
                 status: result.success ? "ok" : "failed",
@@ -416,6 +792,7 @@ export class RelayRuntime {
                 agentId: info.agentId,
                 threadId: info.threadId,
                 workspace: info.workspace,
+                actor,
                 description: "login",
                 detail: result.message,
             });
@@ -427,7 +804,7 @@ export class RelayRuntime {
             }
         }
     }
-    async logout(agentId) {
+    async logout(agentId, actor) {
         const { session, dispose } = await this.getControlSession(agentId);
         try {
             const info = this.publicInfo(session);
@@ -461,6 +838,16 @@ export class RelayRuntime {
                 };
             }
             const result = await this.startAgentLogout(info);
+            this.appendActivity({
+                source: "web",
+                status: result.success ? "info" : "failed",
+                type: result.success ? "logout_completed" : "logout_failed",
+                threadId: info.threadId,
+                workspace: info.workspace,
+                agentId: info.agentId,
+                actor,
+                detail: result.message,
+            });
             this.appendAudit({
                 action: "command",
                 status: result.success ? "ok" : "failed",
@@ -468,6 +855,7 @@ export class RelayRuntime {
                 agentId: info.agentId,
                 threadId: info.threadId,
                 workspace: info.workspace,
+                actor,
                 description: "logout",
                 detail: result.message,
             });
@@ -495,18 +883,29 @@ export class RelayRuntime {
             activity: this.activity({ limit: 100 }).filter((event) => event.threadId === threadId),
         };
     }
-    async clearChatHistory() {
+    async clearChatHistory(actor) {
         const session = await this.getSession(true);
-        const removed = this.chatStore.clear(this.publicInfo(session).threadId);
+        const info = this.publicInfo(session);
+        const removed = this.chatStore.clear(info.threadId);
         const messages = await this.chatHistory();
         this.broadcast({ type: "chat_history", messages });
+        this.appendActivity({
+            source: "web",
+            status: "info",
+            type: "chat_history_cleared",
+            threadId: info.threadId,
+            workspace: info.workspace,
+            agentId: info.agentId,
+            actor,
+            detail: `${removed} messages removed.`,
+        });
         return { removed, messages };
     }
     activity(options = {}) {
         const currentInfo = this.registry.get(WEB_CONTEXT_KEY)?.getInfo();
         return this.activityStore.list(options).map((event) => this.enrichActivityEvent(event, currentInfo));
     }
-    async retry() {
+    async retry(actor) {
         const cached = this.queueService.getLastPrompt();
         if (!cached) {
             throw new Error("Nothing to retry. Send a message first.");
@@ -515,12 +914,13 @@ export class RelayRuntime {
             action: "command",
             status: "ok",
             contextKey: WEB_CONTEXT_KEY,
+            actor,
             description: "retry",
             detail: cached.description,
         });
-        return this.sendEnvelope(cached);
+        return this.sendEnvelope({ ...cached, activityActor: cached.activityActor ?? actor }, actor);
     }
-    async sync() {
+    async sync(actor) {
         const session = await this.getSession(true);
         const info = this.publicInfo(session);
         if (!(info.capabilities ?? CODEX_AGENT_CAPABILITIES).externalActivity) {
@@ -537,6 +937,7 @@ export class RelayRuntime {
             threadId: result.info.threadId,
             workspace: result.info.workspace,
             agentId: result.info.agentId,
+            actor,
             detail: result.changedFields.length > 0 ? result.changedFields.join(", ") : "already in sync",
         });
         this.appendAudit({
@@ -546,6 +947,7 @@ export class RelayRuntime {
             agentId: result.info.agentId,
             threadId: result.info.threadId,
             workspace: result.info.workspace,
+            actor,
             description: "sync",
             detail: result.changedFields.join(", ") || "none",
         });
@@ -612,15 +1014,26 @@ export class RelayRuntime {
         });
         return session.listModels();
     }
-    async setAgent(agentId) {
+    async setAgent(agentId, actor) {
         if (!enabledAgents(this.config).includes(agentId)) {
             throw new Error(`Agent is not enabled: ${agentId}`);
         }
         const session = await this.registry.switchAgent(WEB_CONTEXT_KEY, agentId);
         this.updateSession(session);
+        const info = this.publicInfo(session);
+        this.appendActivity({
+            source: "web",
+            status: "info",
+            type: "agent_switch",
+            threadId: info.threadId,
+            workspace: info.workspace,
+            agentId: info.agentId,
+            actor,
+            detail: `Dashboard switched agent to ${info.agentLabel}.`,
+        });
         return this.publicInfo(session);
     }
-    async newSession(options = {}) {
+    async newSession(options = {}, actor) {
         const session = options.agentId ? await this.registry.switchAgent(WEB_CONTEXT_KEY, options.agentId) : await this.getSession(true);
         this.ensureIdle(session);
         if (options.reasoningEffort) {
@@ -645,11 +1058,12 @@ export class RelayRuntime {
             threadId: info.threadId,
             workspace: info.workspace,
             agentId: info.agentId,
+            actor,
             detail: "New dashboard session created.",
         });
         return this.publicInfo(session);
     }
-    async switchSession(threadId) {
+    async switchSession(threadId, actor) {
         const session = await this.getSession(true);
         this.ensureIdle(session);
         const info = await session.switchSession(threadId);
@@ -662,21 +1076,24 @@ export class RelayRuntime {
             threadId: info.threadId,
             workspace: info.workspace,
             agentId: info.agentId,
+            actor,
             detail: "Dashboard switched session.",
         });
         return this.publicInfo(session);
     }
-    async attachSession(threadId) {
-        return this.switchSession(threadId);
+    async attachSession(threadId, actor) {
+        return this.switchSession(threadId, actor);
     }
-    async setModel(model) {
+    async setModel(model, actor) {
         const session = await this.getSession(true);
         this.ensureIdle(session);
         await session.setModelForCurrentSession(model);
         this.updateSession(session);
-        return this.publicInfo(session);
+        const info = this.publicInfo(session);
+        this.appendActivity({ source: "web", status: "info", type: "model_changed", threadId: info.threadId, workspace: info.workspace, agentId: info.agentId, actor, detail: model });
+        return info;
     }
-    async setReasoningEffort(effort) {
+    async setReasoningEffort(effort, actor) {
         const session = await this.getSession(true);
         this.ensureIdle(session);
         const options = agentReasoningOptions(session.getInfo().agentId);
@@ -685,9 +1102,11 @@ export class RelayRuntime {
         }
         await session.setReasoningEffortForCurrentSession(effort);
         this.updateSession(session);
-        return this.publicInfo(session);
+        const info = this.publicInfo(session);
+        this.appendActivity({ source: "web", status: "info", type: "reasoning_changed", threadId: info.threadId, workspace: info.workspace, agentId: info.agentId, actor, detail: effort });
+        return info;
     }
-    async setFastMode(enabled) {
+    async setFastMode(enabled, actor) {
         const session = await this.getSession(true);
         this.ensureIdle(session);
         if (!(session.getInfo().capabilities ?? CODEX_AGENT_CAPABILITIES).fastMode) {
@@ -695,23 +1114,29 @@ export class RelayRuntime {
         }
         session.setFastMode(enabled);
         this.updateSession(session);
-        return this.publicInfo(session);
+        const info = this.publicInfo(session);
+        this.appendActivity({ source: "web", status: "info", type: "fast_mode_changed", threadId: info.threadId, workspace: info.workspace, agentId: info.agentId, actor, detail: enabled ? "on" : "off" });
+        return info;
     }
-    async setLaunchProfile(profileId) {
+    async setLaunchProfile(profileId, actor) {
         const session = await this.getSession(true);
         this.ensureIdle(session);
         session.setLaunchProfile(profileId);
         this.updateSession(session);
-        return this.publicInfo(session);
+        const info = this.publicInfo(session);
+        this.appendActivity({ source: "web", status: "info", type: "launch_profile_changed", threadId: info.threadId, workspace: info.workspace, agentId: info.agentId, actor, detail: info.launchProfileLabel ?? profileId });
+        return info;
     }
-    async handback() {
+    async handback(actor) {
         const session = await this.getSession(true);
         this.ensureIdle(session);
         const result = session.handback();
         this.updateSession(session);
+        const info = this.publicInfo(session);
+        this.appendActivity({ source: "web", status: "info", type: "handback", threadId: result.threadId, workspace: result.workspace, agentId: info.agentId, actor, detail: result.command ?? "Thread handed back." });
         return result;
     }
-    async abort() {
+    async abort(actor) {
         const session = await this.getSession(true);
         const snapshot = getExternalSnapshotForSession(session, this.config, { maxEvents: 0 });
         if (snapshot?.activity.active && !session.isProcessing()) {
@@ -721,19 +1146,23 @@ export class RelayRuntime {
                 message: `Cannot abort the external ${snapshot.agentLabel} CLI task from NordRelay. Stop it in the terminal where it is running.`,
                 at: new Date().toISOString(),
             });
+            const info = this.publicInfo(session);
+            this.appendActivity({ source: "web", status: "aborted", type: "prompt_abort_rejected", threadId: info.threadId, workspace: info.workspace, agentId: info.agentId, actor, detail: `External ${snapshot.agentLabel} CLI task is active.` });
             return;
         }
         await session.abort();
+        const info = this.publicInfo(session);
+        this.appendActivity({ source: "web", status: "aborted", type: "prompt_aborted", threadId: info.threadId, workspace: info.workspace, agentId: info.agentId, actor, detail: "Current operation aborted." });
         this.broadcast({ type: "status", level: "warn", message: "Current operation aborted.", at: new Date().toISOString() });
     }
-    async sendPrompt(text) {
+    async sendPrompt(text, actor) {
         const trimmed = text.trim();
         if (!trimmed) {
             throw new Error("Prompt is empty.");
         }
-        return this.sendEnvelope(toPromptEnvelope(trimmed));
+        return this.sendEnvelope({ ...toPromptEnvelope(trimmed), activityActor: actor }, actor);
     }
-    async sendUploadPrompt(options) {
+    async sendUploadPrompt(options, actor) {
         const text = options.text?.trim() ?? "";
         const files = options.files.filter((file) => file.data.byteLength > 0);
         if (!text && files.length === 0) {
@@ -768,9 +1197,32 @@ export class RelayRuntime {
                 const transcript = result.text.trim();
                 if (transcript) {
                     transcriptParts.push(`Audio transcript (${staged.safeName}, via ${result.backend}):\n${transcript}`);
+                    this.appendActivity({
+                        source: "web",
+                        status: "completed",
+                        type: "voice_transcribed",
+                        threadId: session.getInfo().threadId,
+                        workspace,
+                        agentId: session.getInfo().agentId,
+                        actor,
+                        detail: `${staged.safeName} via ${result.backend}`,
+                        durationMs: result.durationMs,
+                    });
                 }
             }
         }
+        if (stagedFiles.length > 0) {
+            this.appendActivity({
+                source: "web",
+                status: "info",
+                type: "attachment_staged",
+                threadId: session.getInfo().threadId,
+                workspace,
+                agentId: session.getInfo().agentId,
+                actor,
+                detail: `${stagedFiles.length} file(s): ${stagedFiles.map((file) => file.safeName).join(", ")}`,
+            });
+        }
         const audioOnly = stagedFiles.length > 0 && stagedFiles.every((file) => file.mimeType.startsWith("audio/"));
         if (this.config.voiceTranscribeOnly && audioOnly && !text) {
             return {
@@ -791,14 +1243,15 @@ export class RelayRuntime {
         if (stagedFiles.length > 0) {
             promptInput.stagedFileInstructions = buildFileInstructions(stagedFiles, outDir);
         }
-        const result = await this.sendEnvelope(toPromptEnvelope(promptInput, outDir));
+        const result = await this.sendEnvelope({ ...toPromptEnvelope(promptInput, outDir), activityActor: actor }, actor);
         return {
             ...result,
             transcript: transcriptParts.join("\n\n") || undefined,
             files: uploadFileDtos(stagedFiles),
         };
     }
-    async sendEnvelope(envelope) {
+    async sendEnvelope(envelope, actor) {
+        const activityActor = envelope.activityActor ?? actor;
         const session = await this.getSession(false);
         const external = getExternalSnapshotForSession(session, this.config, { maxEvents: 0 });
         if (session.isProcessing() || external?.activity.active) {
@@ -811,6 +1264,7 @@ export class RelayRuntime {
                 threadId: info.threadId,
                 workspace: info.workspace,
                 agentId: info.agentId,
+                actor: activityActor,
                 prompt: envelope.description,
                 detail: external?.activity.active
                     ? `Queued because ${external.agentLabel} CLI is still processing another task.`
@@ -824,6 +1278,7 @@ export class RelayRuntime {
                 threadId: info.threadId,
                 workspace: info.workspace,
                 promptId: queued.id,
+                actor: activityActor,
                 description: envelope.description,
             });
             if (external?.activity.active) {
@@ -832,7 +1287,7 @@ export class RelayRuntime {
             this.broadcastQueue();
             return { queued: true, queueId: queued.id };
         }
-        void this.runPrompt(session, envelope).catch((error) => {
+        void this.runPrompt(session, { ...envelope, activityActor }).catch((error) => {
             this.broadcast({ type: "turn_error", id: this.currentTurnId ?? "turn", error: friendlyErrorText(error), at: new Date().toISOString() });
         });
         return { queued: false };
@@ -843,7 +1298,9 @@ export class RelayRuntime {
     queuePaused() {
         return this.queueService.isPaused();
     }
-    queueAction(action, id) {
+    queueAction(action, id, actor) {
+        const before = this.queueService.rawList();
+        const affected = id ? before.find((item) => item.id === id) : undefined;
         this.queueService.apply(action, id);
         if (id && action === "run") {
             void this.drainQueue().catch((error) => this.broadcastStatus(friendlyErrorText(error), "error"));
@@ -851,15 +1308,18 @@ export class RelayRuntime {
         this.appendActivity({
             source: "web",
             status: "info",
-            type: "queue_updated",
+            type: `queue_${action}`,
             threadId: null,
             workspace: this.config.workspace,
-            detail: id ? `${action}: ${id}` : action,
+            actor,
+            prompt: affected?.description,
+            detail: id ? `${action}: ${id}` : `${action}: ${before.length} queued`,
         });
         this.appendAudit({
             action: "queue_updated",
             status: "ok",
             contextKey: WEB_CONTEXT_KEY,
+            actor,
             description: id ? `${action}: ${id}` : action,
         });
         this.broadcastQueue();
@@ -873,13 +1333,39 @@ export class RelayRuntime {
         const session = await this.getSession(true);
         return this.artifactService.get(session.getInfo().workspace, turnId);
     }
-    async deleteArtifact(turnId) {
+    async deleteArtifact(turnId, actor) {
         const session = await this.getSession(true);
-        return this.artifactService.delete(session.getInfo().workspace, turnId);
+        const info = this.publicInfo(session);
+        const removed = await this.artifactService.delete(info.workspace, turnId);
+        this.appendActivity({
+            source: "web",
+            status: removed ? "info" : "failed",
+            type: "artifact_deleted",
+            threadId: info.threadId,
+            workspace: info.workspace,
+            agentId: info.agentId,
+            actor,
+            detail: turnId,
+        });
+        return removed;
     }
-    async createArtifactZip(turnId) {
+    async createArtifactZip(turnId, actor) {
         const session = await this.getSession(true);
-        return this.artifactService.createZip(session.getInfo().workspace, turnId);
+        const info = this.publicInfo(session);
+        const zip = await this.artifactService.createZip(info.workspace, turnId);
+        if (zip) {
+            this.appendActivity({
+                source: "web",
+                status: "info",
+                type: "artifact_zip_created",
+                threadId: info.threadId,
+                workspace: info.workspace,
+                agentId: info.agentId,
+                actor,
+                detail: zip.name,
+            });
+        }
+        return zip;
     }
     async artifactPreview(turnId, relativePath) {
         const session = await this.getSession(true);
@@ -894,7 +1380,7 @@ export class RelayRuntime {
         }
         return readFormattedLogTail(lines);
     }
-    clearLogs(target = "connector") {
+    clearLogs(target = "connector", actor) {
         const result = clearLogFile(target === "update" ? getUpdateLogPath() : target === "agent-updates" ? getAgentUpdateLogPath() : getConnectorLogPath());
         this.appendActivity({
             source: "web",
@@ -902,11 +1388,20 @@ export class RelayRuntime {
             type: "logs_cleared",
             threadId: null,
             workspace: this.config.workspace,
+            actor,
             detail: `Cleared ${target} log.`,
         });
+        this.appendAudit({
+            action: "command",
+            status: "ok",
+            contextKey: WEB_CONTEXT_KEY,
+            actor,
+            description: `clear ${target} log`,
+            detail: result.filePath,
+        });
         return { ok: true, filePath: result.filePath, clearedAt: result.clearedAt.toISOString() };
     }
-    restartConnector() {
+    restartConnector(actor) {
         spawnConnectorRestart();
         this.broadcastStatus("Restart requested. The dashboard may disconnect briefly.", "warn");
         this.appendActivity({
@@ -915,8 +1410,16 @@ export class RelayRuntime {
             type: "restart_requested",
             threadId: null,
             workspace: this.config.workspace,
+            actor,
             detail: "Dashboard requested a connector restart.",
         });
+        this.appendAudit({
+            action: "command",
+            status: "ok",
+            contextKey: WEB_CONTEXT_KEY,
+            actor,
+            description: "restart connector",
+        });
         return { ok: true, message: "Restart requested." };
     }
     dispose() {
@@ -930,6 +1433,234 @@ export class RelayRuntime {
     async getSession(deferThreadStart) {
         return this.registry.getOrCreate(WEB_CONTEXT_KEY, { deferThreadStart });
     }
+    async cached(key, producer) {
+        return (await this.cache.get(key, this.config.dashboardCacheTtlMs, producer)).value;
+    }
+    listKnownContextMetadata() {
+        const contexts = new Map();
+        const add = (meta) => {
+            if (meta?.contextKey) {
+                contexts.set(meta.contextKey, meta);
+            }
+        };
+        for (const meta of this.registry.listContexts()) {
+            add(meta);
+        }
+        const sharedRegistry = new SessionRegistry(this.config);
+        try {
+            for (const meta of sharedRegistry.listContexts()) {
+                add(meta);
+            }
+        }
+        finally {
+            sharedRegistry.disposeAll();
+        }
+        const current = this.registry.get(WEB_CONTEXT_KEY)?.getInfo();
+        if (current) {
+            add({
+                contextKey: WEB_CONTEXT_KEY,
+                agentId: current.agentId,
+                threadId: current.threadId,
+                workspace: current.workspace,
+                model: current.model,
+                reasoningEffort: current.reasoningEffort,
+                launchProfileId: current.nextLaunchProfileId ?? current.launchProfileId,
+                sessionPath: current.sessionPath,
+                updatedAt: Date.now(),
+            });
+        }
+        return [...contexts.values()];
+    }
+    discoverRunningConnectorSessions() {
+        const active = [];
+        const terminal = new Set();
+        const now = Date.now();
+        for (const event of this.activityStore.list({ limit: 500 })) {
+            if (!event.threadId || !event.agentId || !event.contextKey) {
+                continue;
+            }
+            const key = `${event.source}:${event.contextKey}:${event.agentId}:${event.threadId}`;
+            if (isPromptTerminalActivity(event)) {
+                terminal.add(key);
+                continue;
+            }
+            if (event.type !== "prompt_started" || event.status !== "running" || event.source === "cli") {
+                continue;
+            }
+            if (terminal.has(key)) {
+                continue;
+            }
+            const startedMs = Date.parse(event.timestamp);
+            if (!Number.isFinite(startedMs) || now - startedMs > ACTIVE_ACTIVITY_TTL_MS) {
+                continue;
+            }
+            active.push({
+                id: `${event.contextKey}:${event.id}`,
+                contextKey: event.contextKey,
+                sourceContextKey: event.contextKey,
+                source: event.source,
+                status: "running",
+                agentId: event.agentId,
+                agentLabel: event.agentId ? agentLabel(event.agentId) : undefined,
+                threadId: event.threadId,
+                workspace: event.workspace,
+                prompt: event.prompt,
+                startedAt: event.timestamp,
+                updatedAt: event.timestamp,
+                durationMs: Math.max(0, now - startedMs),
+                queueLength: this.promptStore.list(event.contextKey).length,
+                queuePaused: this.promptStore.isPaused(event.contextKey),
+                detail: event.actor?.label ? `Started by ${event.actor.label}` : undefined,
+            });
+        }
+        return active;
+    }
+    discoverActiveCodexSessions(knownContexts, preferences) {
+        if (!this.config.codexEnabled || !enabledAgents(this.config).includes("codex")) {
+            return [];
+        }
+        const capabilities = this.capabilitiesForAgent("codex");
+        if (!capabilities.externalActivity) {
+            return [];
+        }
+        const active = [];
+        for (const thread of listCodexThreads(ACTIVE_CODEX_DISCOVERY_LIMIT)) {
+            const meta = {
+                contextKey: `cli:codex:${thread.id}`,
+                agentId: "codex",
+                threadId: thread.id,
+                workspace: thread.cwd,
+                model: thread.model ?? undefined,
+                reasoningEffort: thread.reasoningEffort ?? undefined,
+                updatedAt: thread.updatedAt.getTime(),
+            };
+            const session = this.externalActiveSession(meta, knownContexts, preferences);
+            if (session) {
+                active.push(session);
+            }
+        }
+        return active;
+    }
+    externalActiveSession(meta, knownContexts, preferences) {
+        if (!meta.threadId) {
+            return null;
+        }
+        const agentId = isAgentId(meta.agentId) ? meta.agentId : this.config.defaultAgent;
+        if (!enabledAgents(this.config).includes(agentId)) {
+            return null;
+        }
+        const capabilities = this.capabilitiesForAgent(agentId);
+        if (!capabilities.externalActivity) {
+            return null;
+        }
+        const snapshot = getExternalSnapshotForSession(this.sessionStubForMetadata(meta, agentId, capabilities), this.config, {
+            maxEvents: 8,
+        });
+        if (!snapshot?.activity.active) {
+            return null;
+        }
+        const startedAt = snapshot.activity.startedAt?.toISOString() ?? new Date().toISOString();
+        const updatedAt = snapshot.activity.updatedAt?.toISOString() ?? new Date().toISOString();
+        const startedMs = Date.parse(startedAt);
+        const sourceContextKey = `cli:${snapshot.agentId}:${snapshot.threadId}`;
+        const mirrorChannels = this.activeMirrorChannels(snapshot.agentId, snapshot.threadId, knownContexts, preferences);
+        const queueLength = mirrorChannels.reduce((sum, mirror) => sum + mirror.queueLength, this.promptStore.list(sourceContextKey).length);
+        const mirrorDetail = mirrorChannels.length > 0
+            ? `Mirroring: ${mirrorChannels.map((mirror) => `${mirror.source} ${mirror.mode}`).join(", ")}`
+            : "Mirroring: none";
+        return {
+            id: `${sourceContextKey}:${snapshot.activity.turnId ?? snapshot.threadId}`,
+            contextKey: sourceContextKey,
+            sourceContextKey,
+            source: "cli",
+            status: "external",
+            agentId: snapshot.agentId,
+            agentLabel: snapshot.agentLabel,
+            threadId: snapshot.threadId,
+            workspace: meta.workspace,
+            prompt: snapshot.latestUserMessage ?? undefined,
+            currentTool: snapshot.latestToolName ?? undefined,
+            lastTool: snapshot.latestToolName ?? undefined,
+            startedAt,
+            updatedAt,
+            durationMs: Number.isFinite(startedMs) ? Math.max(0, Date.now() - startedMs) : 0,
+            queueLength,
+            queuePaused: mirrorChannels.some((mirror) => mirror.queuePaused) || this.promptStore.isPaused(sourceContextKey),
+            mirrorChannels,
+            detail: `${mirrorDetail} | ${snapshot.sourceLabel}: ${snapshot.sourcePath}`,
+        };
+    }
+    activeMirrorChannels(agentId, threadId, knownContexts, preferences) {
+        const mirrors = [];
+        const seen = new Set();
+        for (const meta of knownContexts) {
+            const metaAgentId = meta.agentId ?? this.config.defaultAgent ?? "codex";
+            if (meta.threadId !== threadId || metaAgentId !== agentId) {
+                continue;
+            }
+            const source = activeSessionSourceForContext(meta.contextKey);
+            if (source !== "telegram" && source !== "discord") {
+                continue;
+            }
+            const mode = this.effectiveMirrorMode(meta.contextKey, source, preferences);
+            if (mode === "off" || seen.has(meta.contextKey)) {
+                continue;
+            }
+            seen.add(meta.contextKey);
+            mirrors.push({
+                source,
+                contextKey: meta.contextKey,
+                mode,
+                queueLength: this.promptStore.list(meta.contextKey).length,
+                queuePaused: this.promptStore.isPaused(meta.contextKey),
+            });
+        }
+        return mirrors;
+    }
+    effectiveMirrorMode(contextKey, source, preferences) {
+        const configured = source === "telegram" ? this.config.telegramMirrorMode : this.config.discordMirrorMode;
+        return preferences.get(contextKey).mirrorMode ?? configured;
+    }
+    sessionStubForMetadata(meta, agentId, capabilities) {
+        const info = {
+            agentId,
+            agentLabel: agentLabel(agentId),
+            threadId: meta.threadId,
+            workspace: meta.workspace,
+            model: meta.model,
+            reasoningEffort: meta.reasoningEffort,
+            launchProfileId: meta.launchProfileId ?? this.config.defaultLaunchProfileId,
+            launchProfileLabel: meta.launchProfileId ?? this.config.defaultLaunchProfileId,
+            launchProfileBehavior: "-",
+            sandboxMode: "-",
+            approvalPolicy: "-",
+            fastMode: false,
+            unsafeLaunch: false,
+            sessionPath: meta.sessionPath,
+            capabilities,
+        };
+        return {
+            getInfo: () => info,
+            getActiveThreadId: () => meta.threadId,
+        };
+    }
+    capabilitiesForAgent(agentId) {
+        return listAgentAdapterDescriptors().find((descriptor) => descriptor.id === agentId)?.capabilities ?? CODEX_AGENT_CAPABILITIES;
+    }
+    activeSessionKey(session) {
+        return session.threadId ? `${session.agentId ?? "unknown"}:${session.threadId}` : session.id;
+    }
+    preferredActiveSession(existing, candidate) {
+        if (!existing) {
+            return candidate;
+        }
+        const existingPriority = activeSessionPriority(existing);
+        const candidatePriority = activeSessionPriority(candidate);
+        if (candidatePriority !== existingPriority) {
+            return candidatePriority > existingPriority ? candidate : existing;
+        }
+        return Date.parse(candidate.updatedAt) >= Date.parse(existing.updatedAt) ? candidate : existing;
+    }
     async getControlSession(agentId) {
         const active = await this.getSession(true);
         const activeInfo = this.publicInfo(active);
@@ -945,6 +1676,14 @@ export class RelayRuntime {
         });
         return { session, dispose: true };
     }
+    cliPathOptions() {
+        return {
+            piCliPath: this.config.piCliPath,
+            hermesCliPath: this.config.hermesCliPath,
+            openClawCliPath: this.config.openClawCliPath,
+            claudeCodeCliPath: this.config.claudeCodeCliPath,
+        };
+    }
     async ensureActiveThread(session) {
         if (!session.hasActiveThread()) {
             await session.newThread();
@@ -1009,169 +1748,14 @@ export class RelayRuntime {
         }
     }
     async runPrompt(session, envelope) {
-        await this.ensureActiveThread(session);
-        const info = session.getInfo();
-        if ((info.capabilities ?? CODEX_AGENT_CAPABILITIES).auth) {
-            const auth = await this.checkAgentAuth(info);
-            if (!auth.authenticated) {
-                throw new Error(`${agentLabel(info.agentId)} is not authenticated: ${auth.detail}`);
-            }
-        }
         const workspacePolicy = evaluateWorkspacePolicy(session.getInfo().workspace, this.config);
         if (!workspacePolicy.allowed) {
             throw new Error(workspacePolicy.warning ?? "Current workspace is blocked by policy.");
         }
-        const turnId = randomUUID().slice(0, 12);
-        this.currentTurnId = turnId;
-        this.currentTurnStartedAt = Date.now();
-        this.accumulatedText = "";
-        this.currentProgress = {
-            id: turnId,
-            source: "web",
-            status: "running",
-            prompt: envelope.description,
-            agentId: info.agentId,
-            agentLabel: info.agentLabel,
-            threadId: info.threadId,
-            workspace: info.workspace,
-            startedAt: new Date(this.currentTurnStartedAt).toISOString(),
-            updatedAt: new Date(this.currentTurnStartedAt).toISOString(),
-            durationMs: 0,
-            outputChars: 0,
-            tools: [],
-        };
-        this.queueService.setLastPrompt(envelope);
-        const startedDate = new Date();
-        const startedAt = startedDate.toISOString();
-        this.chatStore.append({
-            threadId: info.threadId ?? "pending",
-            role: "user",
-            text: envelope.description,
-            source: "web",
-            turnId,
-            timestamp: startedAt,
-        });
-        this.appendActivity({
-            source: "web",
-            status: "running",
-            type: "prompt_started",
-            threadId: info.threadId,
-            workspace: info.workspace,
-            agentId: info.agentId,
-            prompt: envelope.description,
-        });
-        this.appendAudit({
-            action: "prompt_started",
-            status: "ok",
-            contextKey: WEB_CONTEXT_KEY,
-            agentId: info.agentId,
-            threadId: info.threadId,
-            workspace: info.workspace,
-            description: envelope.description,
-        });
-        this.broadcast({ type: "turn_start", id: turnId, prompt: envelope.description, at: startedAt, source: "web" });
-        const callbacks = {
-            onTextDelta: (delta) => {
-                this.accumulatedText += delta;
-                this.updateCurrentProgress({ outputChars: this.accumulatedText.length });
-                this.broadcast({ type: "text_delta", id: turnId, delta });
-            },
-            onToolStart: (toolName, toolCallId) => {
-                this.addCurrentTool(toolName);
-                this.broadcast({ type: "tool_start", id: turnId, toolCallId, toolName });
-            },
-            onToolUpdate: (toolCallId, partialResult) => {
-                this.updateCurrentProgress();
-                this.broadcast({ type: "tool_update", id: turnId, toolCallId, partialResult });
-            },
-            onToolEnd: (toolCallId, isError) => {
-                this.updateCurrentProgress({ currentTool: undefined });
-                this.broadcast({ type: "tool_end", id: turnId, toolCallId, isError });
-            },
-            onTodoUpdate: (items) => {
-                this.updateCurrentProgress({ detail: `Plan: ${items.filter((item) => item.completed).length}/${items.length} done` });
-                this.broadcast({ type: "todo_update", id: turnId, items });
-            },
-            onTurnComplete: () => { },
-            onAgentEnd: () => this.broadcast({ type: "turn_complete", id: turnId, at: new Date().toISOString() }),
-        };
         try {
-            await session.prompt(envelope.input, callbacks);
-            this.updateSession(session);
-            await this.artifactService.persistWorkspaceArtifactsForTurn(session.getInfo().workspace, turnId, startedDate);
-            if (this.accumulatedText.trim()) {
-                this.chatStore.append({
-                    threadId: info.threadId ?? "pending",
-                    role: "agent",
-                    text: this.accumulatedText,
-                    source: "web",
-                    turnId,
-                });
-            }
-            this.appendActivity({
-                source: "web",
-                status: "completed",
-                type: "prompt_completed",
-                threadId: info.threadId,
-                workspace: info.workspace,
-                agentId: info.agentId,
-                prompt: envelope.description,
-                durationMs: Date.now() - this.currentTurnStartedAt,
-            });
-            this.appendAudit({
-                action: "prompt_completed",
-                status: "ok",
-                contextKey: WEB_CONTEXT_KEY,
-                agentId: info.agentId,
-                threadId: info.threadId,
-                workspace: info.workspace,
-                description: envelope.description,
-            });
-            this.updateCurrentProgress({ status: "completed" });
-            this.broadcast({ type: "turn_complete", id: turnId, at: new Date().toISOString() });
-            this.broadcast({ type: "chat_history", messages: await this.chatHistory() });
-        }
-        catch (error) {
-            const errorText = friendlyErrorText(error);
-            this.chatStore.append({
-                threadId: info.threadId ?? "pending",
-                role: "system",
-                text: `Error: ${errorText}`,
-                source: "web",
-                turnId,
-            });
-            this.appendActivity({
-                source: "web",
-                status: "failed",
-                type: "prompt_failed",
-                threadId: info.threadId,
-                workspace: info.workspace,
-                agentId: info.agentId,
-                prompt: envelope.description,
-                detail: errorText,
-                durationMs: Date.now() - this.currentTurnStartedAt,
-            });
-            this.appendAudit({
-                action: "prompt_failed",
-                status: "failed",
-                contextKey: WEB_CONTEXT_KEY,
-                agentId: info.agentId,
-                threadId: info.threadId,
-                workspace: info.workspace,
-                description: envelope.description,
-                detail: errorText,
-            });
-            this.updateCurrentProgress({ status: "failed", detail: errorText });
-            this.broadcast({ type: "turn_error", id: turnId, error: errorText, at: new Date().toISOString() });
-            this.broadcast({ type: "chat_history", messages: await this.chatHistory() });
-            throw error;
+            await this.turnService.run(session, envelope);
         }
         finally {
-            this.currentTurnId = null;
-            if (this.currentProgress) {
-                this.currentProgress.durationMs = Date.now() - this.currentTurnStartedAt;
-                this.currentProgress.updatedAt = new Date().toISOString();
-            }
             await this.drainQueue();
         }
     }
@@ -1204,6 +1788,40 @@ export class RelayRuntime {
         this.registry.updateMetadata(WEB_CONTEXT_KEY, session);
         this.broadcast({ type: "session_update", session: this.publicInfo(session) });
     }
+    recordActivity(input) {
+        return this.appendActivity(input);
+    }
+    recordAgentUpdateLifecycle(job) {
+        const previous = this.agentUpdateStates.get(job.id);
+        const actor = this.agentUpdateActors.get(job.id);
+        if (job.needsInput && !previous?.needsInput) {
+            this.appendActivity({
+                source: "web",
+                status: "info",
+                type: "agent_update_input_required",
+                agentId: job.agentId,
+                threadId: null,
+                workspace: this.config.workspace,
+                actor,
+                detail: `${job.agentLabel} ${job.operation} may require input.`,
+            });
+        }
+        if (job.status !== "running" && previous?.status === "running") {
+            this.appendActivity({
+                source: "web",
+                status: job.status === "completed" ? "completed" : job.status === "cancelled" ? "aborted" : "failed",
+                type: job.operation === "install" ? `agent_install_${job.status}` : `agent_update_${job.status}`,
+                agentId: job.agentId,
+                threadId: null,
+                workspace: this.config.workspace,
+                actor,
+                detail: job.error ?? `${job.agentLabel} ${job.operation} ${job.status}.`,
+                durationMs: Math.max(0, Date.parse(job.finishedAt ?? job.updatedAt) - Date.parse(job.startedAt)),
+            });
+            this.agentUpdateActors.delete(job.id);
+        }
+        this.agentUpdateStates.set(job.id, { status: job.status, needsInput: job.needsInput });
+    }
     appendActivity(input) {
         const event = this.activityStore.append(this.enrichActivityInput(input));
         this.broadcast({ type: "activity_update", events: this.activity({ limit: 50 }) });
@@ -1341,6 +1959,123 @@ function hostLogoutCommand(info, config) {
     }
     return "codex logout";
 }
+function activeSessionSourceForContext(contextKey) {
+    const channelId = channelIdForContextKey(contextKey);
+    if (channelId === "telegram") {
+        return "telegram";
+    }
+    if (channelId === "discord") {
+        return "discord";
+    }
+    if (channelId === "web") {
+        return "web";
+    }
+    return "cli";
+}
+function activeSessionPriority(session) {
+    if (session.status === "running") {
+        return 3;
+    }
+    return session.contextKey.startsWith("cli:") ? 1 : 2;
+}
+function isPromptTerminalActivity(event) {
+    return event.status === "completed" ||
+        event.status === "failed" ||
+        event.status === "aborted" ||
+        event.type === "prompt_completed" ||
+        event.type === "prompt_failed" ||
+        event.type === "prompt_aborted";
+}
+function taskToUnifiedJob(id, kind, title, task, options) {
+    return {
+        id,
+        kind,
+        title,
+        status: task.status,
+        source: task.source,
+        agentId: task.agentId,
+        agentLabel: task.agentLabel,
+        threadId: task.threadId,
+        workspace: task.workspace,
+        startedAt: task.startedAt,
+        updatedAt: task.updatedAt,
+        durationMs: task.durationMs,
+        summary: task.prompt || task.detail,
+        logTail: task.currentTool || task.lastTool ? `Current tool: ${task.currentTool ?? "-"}\nLast tool: ${task.lastTool ?? "-"}` : undefined,
+        ...options,
+    };
+}
+function activityToUnifiedJob(event, kind, title, options) {
+    return {
+        id: `${kind}:${event.id}`,
+        kind,
+        title,
+        status: event.status,
+        source: event.source,
+        agentId: event.agentId,
+        threadId: event.threadId,
+        workspace: event.workspace,
+        owner: event.actor,
+        startedAt: event.timestamp,
+        updatedAt: event.timestamp,
+        finishedAt: event.timestamp,
+        durationMs: event.durationMs,
+        summary: event.prompt || event.detail,
+        logPath: event.detail,
+        logTail: event.detail,
+        ...options,
+    };
+}
+function promptActivityToUnifiedJob(event) {
+    const status = event.status === "info" ? "completed" : event.status;
+    const sourceLabel = event.source === "web"
+        ? "WebUI"
+        : event.source === "telegram"
+            ? "Telegram"
+            : event.source === "discord"
+                ? "Discord"
+                : "CLI";
+    const promptKey = event.threadId ?? event.contextKey ?? event.id;
+    return {
+        id: `prompt:${event.source}:${promptKey}:${event.id}`,
+        kind: event.source === "cli" ? "external-turn" : "web-turn",
+        title: `${sourceLabel} prompt`,
+        status,
+        source: event.source,
+        agentId: event.agentId,
+        threadId: event.threadId,
+        workspace: event.workspace,
+        owner: event.actor,
+        startedAt: event.timestamp,
+        updatedAt: event.timestamp,
+        finishedAt: status === "running" || status === "queued" ? undefined : event.timestamp,
+        durationMs: event.durationMs,
+        summary: event.prompt || event.detail,
+        logTail: event.detail,
+        canCancel: status === "running" && event.source === "web",
+        canRetry: status !== "running",
+        canReadLog: Boolean(event.detail || event.prompt),
+    };
+}
+function agentUpdateStatusToUnified(status) {
+    if (status === "cancelled")
+        return "aborted";
+    if (status === "running")
+        return "running";
+    if (status === "completed")
+        return "completed";
+    return "failed";
+}
+function dedupeJobs(jobs) {
+    const seen = new Set();
+    return jobs.filter((job) => {
+        if (seen.has(job.id)) {
+            return false;
+        }
+        seen.add(job.id);
+        return true;
+    });
+}
 function normalizeMimeType(value, name) {
     const configured = value?.trim();
     if (configured) {