@nordbyte/nordrelay 0.8.1 → 0.8.3

package/dist/runtime/relay-runtime.js

@@ -0,0 +1,461 @@
+import { randomUUID } from "node:crypto";
+import { ensureOutDir } from "../artifacts/artifacts.js";
+import { buildFileInstructions, outboxPath, stageFile, } from "../artifacts/attachments.js";
+import { CODEX_AGENT_CAPABILITIES, agentLabel, agentReasoningLabel, agentReasoningOptions, isAgentId, } from "../agents/shared/agent.js";
+import { getExternalSnapshotForSession } from "../agents/shared/agent-activity.js";
+import { listAgentAdapterDescriptors } from "../agents/shared/agent-adapter.js";
+import { AgentUpdateManager } from "../agents/shared/agent-updates.js";
+import { createAgentSessionService, enabledAgents } from "../agents/shared/agent-factory.js";
+import { AuditLogStore } from "../access/audit-log.js";
+import { BotPreferencesStore } from "../state/bot-preferences.js";
+import { ChannelCommandService } from "../channels/shared/channel-command-service.js";
+import { ChannelTurnService } from "../channels/shared/channel-turn-service.js";
+import { activeSessionSourceForContextKey, ChannelMirrorRegistry } from "../channels/shared/channel-mirror-registry.js";
+import { listThreads as listCodexThreads } from "../agents/codex/codex-state.js";
+import { friendlyErrorText } from "../core/error-messages.js";
+import { clearLogFile, getAgentUpdateLogPath, getConnectorHealth, getConnectorLogPath, getPackageVersion, getUpdateLogPath, getVersionChecks, readConnectorState, readFormattedLogTail, spawnConnectorRestart, spawnSelfUpdate } from "../support/operations.js";
+import { PromptStore, toPromptEnvelope } from "../state/prompt-store.js";
+import { UnifiedJobStore } from "../state/job-store.js";
+import { buildRuntimeMetrics } from "./metrics.js";
+import { RelayArtifactService } from "./relay-artifact-service.js";
+import { RelayAuthService } from "./relay-auth-service.js";
+import { RelayExternalActivityMonitor } from "./relay-external-activity-monitor.js";
+import { RelayQueueService } from "./relay-queue-service.js";
+import { RuntimeSnapshotCache } from "./runtime-cache.js";
+import { activeSessionPriority, activityToUnifiedJob, agentUpdateStatusToUnified, dedupeJobs, hostLoginCommand, hostLogoutCommand, isPromptTerminalActivity, normalizeMimeType, promptActivityToUnifiedJob, shouldRefreshActiveSessions, taskToUnifiedJob, uploadFileDtos, } from "./relay-runtime-helpers.js";
+import { RelayDashboardService } from "./relay-dashboard-service.js";
+import { capabilitiesOf } from "../channels/shared/bot-rendering.js";
+import { renderSessionInfoPlain, renderSessionUsageRows } from "../channels/shared/session-format.js";
+import { SessionLockStore } from "../access/session-locks.js";
+import { SessionRegistry } from "../state/session-registry.js";
+import { createSupportBundle } from "../support/support-bundle.js";
+import { transcribeAudio } from "../artifacts/voice.js";
+import { WebActivityStore, WebChatStore, } from "../web/web-state.js";
+import { evaluateWorkspacePolicy, filterAllowedWorkspaces } from "../core/workspace-policy.js";
+import { relayRuntimeSubscribe, relayRuntimeSnapshot, relayRuntimeStatus, relayRuntimeBootstrapStatus, relayRuntimeVersion, relayRuntimeDiagnostics, relayRuntimeAdapterHealth, relayRuntimePermissions, relayRuntimeMetrics, relayRuntimeAudit, relayRuntimeAuditPage, relayRuntimeSupportBundle, relayRuntimeLogs, relayRuntimeClearLogs, relayRuntimeRestartConnector, relayRuntimeDispose } from "./relay-runtime-dashboard.js";
+import { relayRuntimeTrace } from "./relay-runtime-trace.js";
+import { relayRuntimeUpdateConnector, relayRuntimeAgentUpdateJobs, relayRuntimeStartAgentUpdate, relayRuntimeAgentUpdateLog, relayRuntimeDeleteAgentUpdateLog, relayRuntimeSendAgentUpdateInput, relayRuntimeCancelAgentUpdate, relayRuntimeTasks, relayRuntimeJobs, relayRuntimeJobLog, relayRuntimeJobAction, relayRuntimeRecordAgentUpdateLifecycle } from "./relay-runtime-updates-jobs.js";
+import { relayRuntimeActiveSessions, relayRuntimeGetSession, relayRuntimeListKnownContextMetadata, relayRuntimeDiscoverRunningConnectorSessions, relayRuntimeDiscoverActiveCodexSessions, relayRuntimeExternalActiveSession, relayRuntimeSessionStubForMetadata, relayRuntimeCapabilitiesForAgent, relayRuntimeActiveSessionKey, relayRuntimePreferredActiveSession, relayRuntimeRecordActivity, relayRuntimeAppendActivity, relayRuntimeEnrichActivityInput, relayRuntimeEnrichActivityEvent, relayRuntimeEnrichActivityFields, relayRuntimeAppendAudit, relayRuntimeUpdateCurrentProgress, relayRuntimeAddCurrentTool, relayRuntimeBroadcastQueue, relayRuntimeBroadcastStatus, relayRuntimeBroadcast, relayRuntimeScheduleActiveSessionsBroadcast, relayRuntimePublicInfo } from "./relay-runtime-active-sessions.js";
+import { relayRuntimeLocks, relayRuntimeLockWebSession, relayRuntimeUnlockWebSession, relayRuntimeControlOptions, relayRuntimeAuthStatus, relayRuntimeLogin, relayRuntimeLogout, relayRuntimeChatHistory, relayRuntimeWebMirrorPreference, relayRuntimeSessionDetail, relayRuntimeClearChatHistory, relayRuntimeActivity, relayRuntimeActivityPage, relayRuntimeRetry, relayRuntimeSync, relayRuntimeListSessions, relayRuntimeListSessionsPage, relayRuntimeFilteredSessions, relayRuntimeListModels, relayRuntimeSetAgent, relayRuntimeNewSession, relayRuntimeSwitchSession, relayRuntimeAttachSession, relayRuntimeSetModel, relayRuntimeSetReasoningEffort, relayRuntimeSetFastMode, relayRuntimeSetLaunchProfile, relayRuntimeHandback, relayRuntimeAbort, relayRuntimeGetControlSession, relayRuntimeCliPathOptions } from "./relay-runtime-sessions.js";
+import { relayRuntimeSendPrompt, relayRuntimeSendUploadPrompt, relayRuntimeSendEnvelope, relayRuntimeQueue, relayRuntimeQueuePaused, relayRuntimeQueueAction, relayRuntimeArtifacts, relayRuntimeArtifact, relayRuntimeDeleteArtifact, relayRuntimeCreateArtifactZip, relayRuntimeArtifactPreview, relayRuntimeEnsureActiveThread, relayRuntimeEnsureIdle, relayRuntimeRunPrompt, relayRuntimeDrainQueue, relayRuntimeUpdateSession } from "./relay-runtime-prompt-queue-artifacts.js";
+export 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 {
+    config;
+    contextKey;
+    registry;
+    promptStore;
+    chatStore;
+    activityStore;
+    auditStore;
+    preferencesStore;
+    lockStore;
+    agentUpdates;
+    queueService;
+    jobStore;
+    artifactService;
+    mirrorRegistry;
+    externalActivityMonitor;
+    cache = new RuntimeSnapshotCache();
+    dashboardService;
+    turnService;
+    authService;
+    subscribers = new Set();
+    agentUpdateActors = new Map();
+    agentUpdateStates = new Map();
+    externalMonitor;
+    activeSessionsBroadcastTimer = null;
+    activeSessionsLastBroadcastAt = 0;
+    draining = false;
+    currentTurnId = null;
+    accumulatedText = "";
+    currentTurnStartedAt = 0;
+    currentProgress = null;
+    constructor(config, options = {}) {
+        this.config = config;
+        this.contextKey = options.contextKey ?? WEB_CONTEXT_KEY;
+        this.registry = new SessionRegistry(config, {
+            fileName: options.registryFileName ?? "web-contexts.json",
+            sqliteKey: options.registrySqliteKey ?? "web-contexts",
+        });
+        this.promptStore = new PromptStore(config.workspace, config.stateBackend);
+        this.chatStore = new WebChatStore(config.workspace, config.stateBackend, MAX_CHAT_HISTORY);
+        this.activityStore = new WebActivityStore(config.workspace, config.stateBackend, config.auditMaxEvents);
+        this.auditStore = new AuditLogStore(config.workspace, config.stateBackend, config.auditMaxEvents);
+        this.preferencesStore = new BotPreferencesStore(config.workspace, config.stateBackend);
+        this.lockStore = new SessionLockStore(config.workspace, config.stateBackend);
+        this.queueService = new RelayQueueService(this.promptStore, this.contextKey);
+        this.jobStore = new UnifiedJobStore(config.workspace, config.stateBackend, config.unifiedJobMaxItems);
+        this.artifactService = new RelayArtifactService(config);
+        this.authService = new RelayAuthService(config);
+        this.mirrorRegistry = new ChannelMirrorRegistry(config, this.promptStore);
+        this.agentUpdates = new AgentUpdateManager({
+            onUpdate: (job) => {
+                this.broadcast({ type: "agent_update", job });
+                this.recordAgentUpdateLifecycle(job);
+            },
+        });
+        this.externalActivityMonitor = new RelayExternalActivityMonitor({
+            config,
+            getSession: () => this.getSession(true),
+            publicInfo: (session) => this.publicInfo(session),
+            queueLength: () => this.queueService.length(),
+            mirrorMode: () => this.preferencesStore.get(this.contextKey).mirrorMode ?? this.config.webMirrorMode,
+            mirrorMinUpdateMs: () => this.config.webMirrorMinUpdateMs,
+            chatStore: this.chatStore,
+            chatHistory: () => this.chatHistory(),
+            persistWorkspaceArtifactsForTurn: (workspace, turnId, startedAt) => this.artifactService.persistWorkspaceArtifactsForTurn(workspace, turnId, startedAt),
+            drainQueue: () => this.drainQueue(),
+            appendActivity: (input) => this.appendActivity(input),
+            broadcast: (event) => this.broadcast(event),
+            broadcastStatus: (message, level) => this.broadcastStatus(message, level),
+        });
+        this.dashboardService = new RelayDashboardService({
+            config,
+            cache: this.cache,
+            snapshot: () => this.snapshot(),
+            getSession: () => this.getSession(true),
+            queuePaused: () => this.queueService.isPaused(),
+            externalMirror: () => this.externalActivityMonitor.snapshot(),
+            authStatus: (agentId) => this.authStatus(agentId),
+            cliPathOptions: () => this.cliPathOptions(),
+        });
+        this.dashboardService.startBackgroundRefresh();
+        if (config.codexExternalBusyCheckMs > 0) {
+            this.externalMonitor = setInterval(() => {
+                void this.externalActivityMonitor.monitorSafe();
+            }, config.codexExternalBusyCheckMs);
+            this.externalMonitor.unref?.();
+        }
+        this.turnService = new ChannelTurnService({
+            source: "web",
+            contextKey: this.contextKey,
+            chatStore: this.chatStore,
+            artifactService: this.artifactService,
+            checkAuth: (info) => this.authService.check(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) {
+        return relayRuntimeSubscribe(this, callback);
+    }
+    async snapshot() {
+        return relayRuntimeSnapshot(this);
+    }
+    async status() {
+        return relayRuntimeStatus(this);
+    }
+    async bootstrapStatus() {
+        return relayRuntimeBootstrapStatus(this);
+    }
+    async version() {
+        return relayRuntimeVersion(this);
+    }
+    updateConnector(actor) {
+        return relayRuntimeUpdateConnector(this, actor);
+    }
+    agentUpdateJobs() {
+        return relayRuntimeAgentUpdateJobs(this);
+    }
+    startAgentUpdate(agentId, operation = "update", actor) {
+        return relayRuntimeStartAgentUpdate(this, agentId, operation, actor);
+    }
+    agentUpdateLog(id) {
+        return relayRuntimeAgentUpdateLog(this, id);
+    }
+    deleteAgentUpdateLog(id, actor) {
+        return relayRuntimeDeleteAgentUpdateLog(this, id, actor);
+    }
+    sendAgentUpdateInput(id, input, actor) {
+        return relayRuntimeSendAgentUpdateInput(this, id, input, actor);
+    }
+    cancelAgentUpdate(id, actor) {
+        return relayRuntimeCancelAgentUpdate(this, id, actor);
+    }
+    async diagnostics() {
+        return relayRuntimeDiagnostics(this);
+    }
+    async adapterHealth() {
+        return relayRuntimeAdapterHealth(this);
+    }
+    permissions() {
+        return relayRuntimePermissions(this);
+    }
+    tasks() {
+        return relayRuntimeTasks(this);
+    }
+    async jobs(options = {}) {
+        return relayRuntimeJobs(this, options);
+    }
+    async jobLog(id) {
+        return relayRuntimeJobLog(this, id);
+    }
+    async jobAction(id, action, actor) {
+        return relayRuntimeJobAction(this, id, action, actor);
+    }
+    async activeSessions() {
+        return relayRuntimeActiveSessions(this);
+    }
+    async metrics() {
+        return relayRuntimeMetrics(this);
+    }
+    audit(options = 50) {
+        return relayRuntimeAudit(this, options);
+    }
+    auditPage(options = {}) {
+        return relayRuntimeAuditPage(this, options);
+    }
+    async trace(correlationId) {
+        return relayRuntimeTrace(this, correlationId);
+    }
+    async supportBundle(actor) {
+        return relayRuntimeSupportBundle(this, actor);
+    }
+    locks() {
+        return relayRuntimeLocks(this);
+    }
+    lockWebSession(ownerName = "Web dashboard", actor) {
+        return relayRuntimeLockWebSession(this, ownerName, actor);
+    }
+    unlockWebSession(actor) {
+        return relayRuntimeUnlockWebSession(this, actor);
+    }
+    async controlOptions(agentId) {
+        return relayRuntimeControlOptions(this, agentId);
+    }
+    async authStatus(agentId) {
+        return relayRuntimeAuthStatus(this, agentId);
+    }
+    async login(agentId, actor) {
+        return relayRuntimeLogin(this, agentId, actor);
+    }
+    async logout(agentId, actor) {
+        return relayRuntimeLogout(this, agentId, actor);
+    }
+    async chatHistory(limit = 200) {
+        return relayRuntimeChatHistory(this, limit);
+    }
+    async webMirrorPreference(argument = "", actor) {
+        return relayRuntimeWebMirrorPreference(this, argument, actor);
+    }
+    async sessionDetail(threadId) {
+        return relayRuntimeSessionDetail(this, threadId);
+    }
+    async clearChatHistory(actor) {
+        return relayRuntimeClearChatHistory(this, actor);
+    }
+    activity(options = {}) {
+        return relayRuntimeActivity(this, options);
+    }
+    activityPage(options = {}) {
+        return relayRuntimeActivityPage(this, options);
+    }
+    async retry(actor) {
+        return relayRuntimeRetry(this, actor);
+    }
+    async sync(actor) {
+        return relayRuntimeSync(this, actor);
+    }
+    async listSessions(limit = 80, query = "", agentId) {
+        return relayRuntimeListSessions(this, limit, query, agentId);
+    }
+    async listSessionsPage(page = 1, pageSize = MAX_WEB_SESSION_PAGE_SIZE, query = "", agentId) {
+        return relayRuntimeListSessionsPage(this, page, pageSize, query, agentId);
+    }
+    filteredSessions(session, query, limit) {
+        return relayRuntimeFilteredSessions(this, session, query, limit);
+    }
+    async listModels() {
+        return relayRuntimeListModels(this);
+    }
+    async setAgent(agentId, actor) {
+        return relayRuntimeSetAgent(this, agentId, actor);
+    }
+    async newSession(options = {}, actor) {
+        return relayRuntimeNewSession(this, options, actor);
+    }
+    async switchSession(threadId, actor) {
+        return relayRuntimeSwitchSession(this, threadId, actor);
+    }
+    async attachSession(threadId, actor) {
+        return relayRuntimeAttachSession(this, threadId, actor);
+    }
+    async setModel(model, actor) {
+        return relayRuntimeSetModel(this, model, actor);
+    }
+    async setReasoningEffort(effort, actor) {
+        return relayRuntimeSetReasoningEffort(this, effort, actor);
+    }
+    async setFastMode(enabled, actor) {
+        return relayRuntimeSetFastMode(this, enabled, actor);
+    }
+    async setLaunchProfile(profileId, actor) {
+        return relayRuntimeSetLaunchProfile(this, profileId, actor);
+    }
+    async handback(actor) {
+        return relayRuntimeHandback(this, actor);
+    }
+    async abort(actor) {
+        return relayRuntimeAbort(this, actor);
+    }
+    async sendPrompt(text, actor) {
+        return relayRuntimeSendPrompt(this, text, actor);
+    }
+    async sendUploadPrompt(options, actor) {
+        return relayRuntimeSendUploadPrompt(this, options, actor);
+    }
+    async sendEnvelope(envelope, actor) {
+        return relayRuntimeSendEnvelope(this, envelope, actor);
+    }
+    queue() {
+        return relayRuntimeQueue(this);
+    }
+    queuePaused() {
+        return relayRuntimeQueuePaused(this);
+    }
+    queueAction(action, id, actor) {
+        return relayRuntimeQueueAction(this, action, id, actor);
+    }
+    async artifacts(limit = 20) {
+        return relayRuntimeArtifacts(this, limit);
+    }
+    async artifact(turnId) {
+        return relayRuntimeArtifact(this, turnId);
+    }
+    async deleteArtifact(turnId, actor) {
+        return relayRuntimeDeleteArtifact(this, turnId, actor);
+    }
+    async createArtifactZip(turnId, actor) {
+        return relayRuntimeCreateArtifactZip(this, turnId, actor);
+    }
+    async artifactPreview(turnId, relativePath) {
+        return relayRuntimeArtifactPreview(this, turnId, relativePath);
+    }
+    async logs(target = "connector", lines = 100) {
+        return relayRuntimeLogs(this, target, lines);
+    }
+    clearLogs(target = "connector", actor) {
+        return relayRuntimeClearLogs(this, target, actor);
+    }
+    restartConnector(actor) {
+        return relayRuntimeRestartConnector(this, actor);
+    }
+    dispose() {
+        return relayRuntimeDispose(this);
+    }
+    async getSession(deferThreadStart) {
+        return relayRuntimeGetSession(this, deferThreadStart);
+    }
+    listKnownContextMetadata() {
+        return relayRuntimeListKnownContextMetadata(this);
+    }
+    discoverRunningConnectorSessions() {
+        return relayRuntimeDiscoverRunningConnectorSessions(this);
+    }
+    discoverActiveCodexSessions(knownContexts, preferences) {
+        return relayRuntimeDiscoverActiveCodexSessions(this, knownContexts, preferences);
+    }
+    externalActiveSession(meta, knownContexts, preferences) {
+        return relayRuntimeExternalActiveSession(this, meta, knownContexts, preferences);
+    }
+    sessionStubForMetadata(meta, agentId, capabilities) {
+        return relayRuntimeSessionStubForMetadata(this, meta, agentId, capabilities);
+    }
+    capabilitiesForAgent(agentId) {
+        return relayRuntimeCapabilitiesForAgent(this, agentId);
+    }
+    activeSessionKey(session) {
+        return relayRuntimeActiveSessionKey(this, session);
+    }
+    preferredActiveSession(existing, candidate) {
+        return relayRuntimePreferredActiveSession(this, existing, candidate);
+    }
+    async getControlSession(agentId) {
+        return relayRuntimeGetControlSession(this, agentId);
+    }
+    cliPathOptions() {
+        return relayRuntimeCliPathOptions(this);
+    }
+    async ensureActiveThread(session) {
+        return relayRuntimeEnsureActiveThread(this, session);
+    }
+    ensureIdle(session) {
+        return relayRuntimeEnsureIdle(this, session);
+    }
+    async runPrompt(session, envelope) {
+        return relayRuntimeRunPrompt(this, session, envelope);
+    }
+    async drainQueue() {
+        return relayRuntimeDrainQueue(this);
+    }
+    updateSession(session) {
+        return relayRuntimeUpdateSession(this, session);
+    }
+    recordActivity(input) {
+        return relayRuntimeRecordActivity(this, input);
+    }
+    recordAgentUpdateLifecycle(job) {
+        return relayRuntimeRecordAgentUpdateLifecycle(this, job);
+    }
+    appendActivity(input) {
+        return relayRuntimeAppendActivity(this, input);
+    }
+    enrichActivityInput(input) {
+        return relayRuntimeEnrichActivityInput(this, input);
+    }
+    enrichActivityEvent(event, info) {
+        return relayRuntimeEnrichActivityEvent(this, event, info);
+    }
+    enrichActivityFields(event, info) {
+        return relayRuntimeEnrichActivityFields(this, event, info);
+    }
+    appendAudit(input) {
+        return relayRuntimeAppendAudit(this, input);
+    }
+    updateCurrentProgress(patch = {}) {
+        return relayRuntimeUpdateCurrentProgress(this, patch);
+    }
+    addCurrentTool(toolName) {
+        return relayRuntimeAddCurrentTool(this, toolName);
+    }
+    broadcastQueue() {
+        return relayRuntimeBroadcastQueue(this);
+    }
+    broadcastStatus(message, level = "info") {
+        return relayRuntimeBroadcastStatus(this, message, level);
+    }
+    broadcast(event) {
+        return relayRuntimeBroadcast(this, event);
+    }
+    scheduleActiveSessionsBroadcast() {
+        return relayRuntimeScheduleActiveSessionsBroadcast(this);
+    }
+    publicInfo(session) {
+        return relayRuntimePublicInfo(this, session);
+    }
+}

package/dist/runtime/runtime-cache.js

@@ -0,0 +1,117 @@
+export class RuntimeSnapshotCache {
+    entries = new Map();
+    register(key, producer) {
+        const entry = this.entries.get(key);
+        if (entry) {
+            entry.producer = producer;
+            return;
+        }
+        this.entries.set(key, { producer, refreshedAt: 0 });
+    }
+    async get(key, ttlMs, producer) {
+        if (producer) {
+            this.register(key, producer);
+        }
+        const now = Date.now();
+        const entry = this.entries.get(key);
+        const activeProducer = producer ?? entry?.producer;
+        if (!activeProducer) {
+            throw new Error(`Runtime cache producer is not registered for ${key}.`);
+        }
+        const hasFreshValue = entry?.value !== undefined && ttlMs > 0 && now - entry.refreshedAt <= ttlMs;
+        if (hasFreshValue) {
+            return {
+                value: entry.value,
+                refreshedAt: new Date(entry.refreshedAt).toISOString(),
+                stale: false,
+            };
+        }
+        if (entry?.value !== undefined) {
+            if (!entry.refresh) {
+                entry.refresh = activeProducer()
+                    .then((value) => {
+                    entry.value = value;
+                    entry.refreshedAt = Date.now();
+                    return value;
+                })
+                    .catch(() => entry.value)
+                    .finally(() => {
+                    entry.refresh = undefined;
+                });
+            }
+            return {
+                value: entry.value,
+                refreshedAt: new Date(entry.refreshedAt).toISOString(),
+                stale: true,
+            };
+        }
+        const pending = entry?.refresh ?? activeProducer();
+        this.entries.set(key, { ...entry, producer: activeProducer, refresh: pending, refreshedAt: now });
+        try {
+            const value = await pending;
+            const refreshedAt = Date.now();
+            this.entries.set(key, { value, refreshedAt, producer: activeProducer });
+            return {
+                value,
+                refreshedAt: new Date(refreshedAt).toISOString(),
+                stale: false,
+            };
+        }
+        catch (error) {
+            this.entries.delete(key);
+            throw error;
+        }
+    }
+    refresh(key) {
+        const entry = this.entries.get(key);
+        if (!entry?.producer) {
+            throw new Error(`Runtime cache producer is not registered for ${key}.`);
+        }
+        if (!entry.refresh) {
+            entry.refresh = entry.producer()
+                .then((value) => {
+                entry.value = value;
+                entry.refreshedAt = Date.now();
+                return value;
+            })
+                .finally(() => {
+                entry.refresh = undefined;
+            });
+        }
+        return entry.refresh.then((value) => ({
+            value,
+            refreshedAt: new Date(entry.refreshedAt).toISOString(),
+            stale: false,
+        }));
+    }
+    warm(keys) {
+        const targetKeys = keys ?? [...this.entries.keys()];
+        for (const key of targetKeys) {
+            if (!this.entries.get(key)?.producer)
+                continue;
+            void this.refresh(key).catch(() => {
+                // Best-effort dashboard warm-up. Foreground requests will surface errors.
+            });
+        }
+    }
+    invalidate(key) {
+        if (key) {
+            const entry = this.entries.get(key);
+            if (entry?.producer) {
+                this.entries.set(key, { producer: entry.producer, refreshedAt: 0 });
+            }
+            else {
+                this.entries.delete(key);
+            }
+            return;
+        }
+        for (const [entryKey, entry] of this.entries.entries()) {
+            if (entry.producer) {
+                this.entries.set(entryKey, { producer: entry.producer, refreshedAt: 0 });
+            }
+            else {
+                this.entries.delete(entryKey);
+            }
+        }
+    }
+}

package/dist/{prompt-store.js → state/prompt-store.js}

@@ -224,6 +224,16 @@ export function toPromptEnvelope(input, artifactOutDir) {
         description: describePromptInput(input),
     };
 }
+export function createCorrelationId() {
+    return randomUUID().replace(/-/g, "").slice(0, 12);
+}
+export function ensurePromptCorrelationId(prompt) {
+    const existing = prompt.correlationId?.trim();
+    if (existing) {
+        return { ...prompt, correlationId: existing };
+    }
+    return { ...prompt, correlationId: createCorrelationId() };
+}
 function createQueueId() {
     return randomUUID().replace(/-/g, "").slice(0, 8);
 }
@@ -232,7 +242,9 @@ function isPromptEnvelope(value) {
         return false;
     }
     const candidate = value;
-    return isCodexPromptInput(candidate.input) && typeof candidate.description === "string";
+    return isCodexPromptInput(candidate.input) &&
+        typeof candidate.description === "string" &&
+        (candidate.correlationId === undefined || typeof candidate.correlationId === "string");
 }
 function isQueuedPrompt(value) {
     return isPromptEnvelope(value) &&

package/dist/{session-registry.js → state/session-registry.js}

@@ -1,6 +1,6 @@
-import { createAgentSessionService } from "./agent-factory.js";
-import { CODEX_AGENT_CAPABILITIES } from "./agent.js";
-import { findLaunchProfile } from "./codex-launch.js";
+import { createAgentSessionService } from "../agents/shared/agent-factory.js";
+import { CODEX_AGENT_CAPABILITIES } from "../agents/shared/agent.js";
+import { findLaunchProfile } from "../agents/codex/codex-launch.js";
 import { createDocumentStore } from "./state-backend.js";
 export class SessionRegistry {
     config;

package/dist/{operations.js → support/operations.js}

@@ -3,12 +3,12 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { readFile, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { describeCodexCli, findExecutableOnPath, resolveCodexCli } from "./codex-cli.js";
-import { findLatestDatabase } from "./codex-state.js";
-import { describeClaudeCodeCli, resolveClaudeCodeCli } from "./claude-code-cli.js";
-import { describeHermesCli, resolveHermesCli } from "./hermes-cli.js";
-import { describeOpenClawCli, resolveOpenClawCli } from "./openclaw-cli.js";
-import { describePiCli, resolvePiCli } from "./pi-cli.js";
+import { describeCodexCli, findExecutableOnPath, resolveCodexCli } from "../agents/codex/codex-cli.js";
+import { findLatestDatabase } from "../agents/codex/codex-state.js";
+import { describeClaudeCodeCli, resolveClaudeCodeCli } from "../agents/claude-code/claude-code-cli.js";
+import { describeHermesCli, resolveHermesCli } from "../agents/hermes/hermes-cli.js";
+import { describeOpenClawCli, resolveOpenClawCli } from "../agents/openclaw/openclaw-cli.js";
+import { describePiCli, resolvePiCli } from "../agents/pi/pi-cli.js";
 const APP_NAME = "nordrelay";
 const PACKAGE_NAME = "@nordbyte/nordrelay";
 const CODEX_PACKAGE_NAME = "@openai/codex";
@@ -480,7 +480,7 @@ export function resolveNpmSpawnCommand(env = process.env) {
             shell: false,
         };
     }
-    const pathMatch = findExecutableOnPath("npm", env.PATH);
+    const pathMatch = findExecutableOnPath("npm", env.PATH, { pathext: env.PATHEXT });
     if (pathMatch) {
         return {
             command: pathMatch,

package/dist/{support-bundle.js → support/support-bundle.js}

@@ -3,7 +3,7 @@ import { mkdir, stat, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { getAgentUpdateLogPath, getConnectorHealth, getConnectorHome, getConnectorLogPath, getConnectorStatePath, getSourceRoot, getUpdateLogPath, getVersionChecks, readFormattedLogTail, resolveNpmSpawnCommand, } from "./operations.js";
-import { redactText } from "./redaction.js";
+import { redactText } from "../core/redaction.js";
 import { createZipBuffer } from "./zip-writer.js";
 export async function createSupportBundle(options) {
     const createdAt = new Date();