@tea-agent/loop-agent 0.40.0-next.4 → 0.40.0-next.6

package/dist/worker/console/workspace-context.js

@@ -0,0 +1,234 @@
+/**
+ * Repo-scoped Workspace Context (2026-08-22 multi-workspace foundation, W1).
+ *
+ * One lazily-created ConsoleContext per workspaceId. Each context INDEPENDENTLY
+ * owns the full operator runtime for its repo root: fingerprint-isolated
+ * appData (via openConsoleAppData), operation/event stores, draft /
+ * confirmation / receipt / interview / assessment stores, Chat session store +
+ * events + deferred Turn registry + ConsolePiRuntime(cwd=repoRoot),
+ * OperatorActionContext, Observe route context, and readiness.
+ *
+ * Invariants:
+ *   - Selecting (viewing) another workspace NEVER disposes a context; running
+ *     Turns / Operations / DAGs continue in the background.
+ *   - dispose() is invoked exactly once per context by the owning server's
+ *     close().
+ *   - bootToken is shared per Console boot: it binds the startup fingerprint
+ *     and bind host, and its confirmationToken signs human-gate tokens for all
+ *     workspaces in this process (single Console security domain).
+ */
+import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { LoopAgentClient } from "../loop-agent/loop-agent-client.js";
+import { openConsoleAppData } from "./app-data.js";
+import { DagConfirmationStore } from "./dag-confirmation.js";
+import { DagExecutionReceiptStore } from "./dag-execution-receipt.js";
+import { DraftStore } from "./draft-store.js";
+import { AssessmentStore } from "./interview/assessment.js";
+import { InterviewSessionStore } from "./interview/session.js";
+import { ChatSessionStore } from "./chat/session-store.js";
+import { createChatEventStore, createChatOperationLinker, } from "./chat/chat-event-store.js";
+import { createChatTurnExecutionRegistry } from "./chat/turn-execution-registry.js";
+import { ConsolePiRuntime } from "./chat/pi-runtime.js";
+import { UserQuestionRegistry } from "./chat/user-questions.js";
+import { TodoListRegistry } from "./chat/todos.js";
+import { createOperationEventStore, } from "./operation-sse.js";
+import { OperationStore } from "./operation-store.js";
+import { probePiReadiness, } from "./pi-readiness.js";
+import { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
+import { NightAuxTicker } from "./night-aux-ticker.js";
+import { createObserveRouteContext, } from "../observe/routes.js";
+import { WorkspaceRegistry } from "./workspace-registry.js";
+import { resolveConsoleDefaultTimeoutMs } from "./server.js";
+/**
+ * Lazily create the full repo-scoped Console context for a registered
+ * workspace record. Pure factory — no global registry; the caller owns
+ * lifecycle (single creation per workspaceId, dispose on server close).
+ */
+export async function createWorkspaceContext(record, deps) {
+    const repoRoot = record.repoRoot;
+    const appData = openConsoleAppData({
+        repoRoot,
+        ...(deps.appDataRoot ? { appDataRoot: deps.appDataRoot } : {}),
+    });
+    const registry = new WorkspaceRegistry(appData);
+    const readiness = await probePiReadiness({
+        override: deps.piReadinessProbe,
+        repoRoot,
+    });
+    let readinessCache = readiness;
+    const artifactRoot = path.join(appData.root, "client-artifacts", appData.fingerprint);
+    const client = deps.createClient?.(artifactRoot) ??
+        new LoopAgentClient({
+            loopAgentBin: resolveSiblingLoopAgentBin(),
+            artifactRoot,
+            resolveIdentity: true,
+            defaultTimeoutMs: resolveConsoleDefaultTimeoutMs(deps.defaultTimeoutMs),
+        });
+    const operations = new OperationStore(appData);
+    const events = createOperationEventStore({
+        persistenceDir: path.join(appData.operations, "events"),
+    });
+    const drafts = new DraftStore(appData);
+    const confirmations = new DagConfirmationStore(appData, deps.bootToken.confirmationToken);
+    const dagExecutionReceipts = new DagExecutionReceiptStore(appData);
+    const interviews = new InterviewSessionStore(appData);
+    const assessments = new AssessmentStore(appData);
+    if (!deps.skipReconcile) {
+        await operations.reconcileOnBoot();
+    }
+    const getReadiness = () => readinessCache;
+    const refreshReadiness = async () => {
+        readinessCache = await probePiReadiness({
+            override: deps.piReadinessProbe,
+            repoRoot,
+        });
+        actionContext.readiness = readinessCache;
+        return readinessCache;
+    };
+    const actionContext = {
+        repoRoot,
+        appData,
+        operatorSessionId: deps.operatorSessionId,
+        client,
+        operations,
+        events,
+        drafts,
+        confirmations,
+        dagExecutionReceipts,
+        humanGateSecret: deps.bootToken.confirmationToken,
+        interviews,
+        assessments,
+        readiness: readinessCache,
+        getReadiness,
+        refreshReadiness,
+        observeBaseUrl: deps.observeBaseUrl,
+        fetchImpl: deps.fetchImpl,
+        getConsoleOrigin: deps.getConsoleOrigin,
+    };
+    const chatStore = new ChatSessionStore(appData);
+    const chatEventEpoch = randomBytes(12).toString("hex");
+    const chatEvents = createChatEventStore({
+        appData,
+        epoch: chatEventEpoch,
+    });
+    const chatTurnExecutions = createChatTurnExecutionRegistry();
+    const questionRegistry = new UserQuestionRegistry(path.join(appData.chats, "user-questions"));
+    const todoRegistry = new TodoListRegistry();
+    questionRegistry.subscribe((change) => {
+        const question = change.question;
+        chatEvents.append(question.sessionId, question.turnId ?? `${question.sessionId}:question`, {
+            kind: `question_${change.type}`,
+            data: { question },
+        });
+    });
+    todoRegistry.subscribe((change) => {
+        chatEvents.append(change.sessionId, change.turnId ?? `${change.sessionId}:todo`, {
+            kind: change.type === "updated" ? "todo_updated" : "todo_cleared",
+            data: {
+                todos: change.todos,
+                ...(change.toolCallId ? { toolCallId: change.toolCallId } : {}),
+            },
+        });
+    });
+    const chatOperationLinker = createChatOperationLinker({
+        chatEvents,
+        operations,
+        operationEvents: events,
+    });
+    const chatRuntime = new ConsolePiRuntime({
+        cwd: repoRoot,
+        sessionDir: appData.chatSessions,
+        resourcePreferencesPath: appData.resourcePreferences,
+        actionContext,
+        questionRegistry,
+        todoRegistry,
+    });
+    const chatRouteDeps = {
+        runtime: chatRuntime,
+        store: chatStore,
+        events: chatEvents,
+        turnExecutions: chatTurnExecutions,
+        questionRegistry,
+        todoRegistry,
+        operationLinker: chatOperationLinker,
+        appData,
+        bootToken: deps.bootToken,
+        getConsoleOrigin: deps.getConsoleOrigin,
+        allowNonLoopbackAccess: deps.allowNonLoopbackAccess,
+    };
+    const { recoverDeferredTurns } = await import("./chat/routes.js");
+    const nightAuxTicker = new NightAuxTicker({ repoRoot, client });
+    const observeRouteContext = createObserveRouteContext(repoRoot, {
+        staticDir: deps.inspectStaticDir,
+    });
+    let disposed = false;
+    const context = {
+        workspaceId: record.workspaceId,
+        record,
+        repoRoot,
+        appData,
+        registry,
+        client,
+        operations,
+        events,
+        drafts,
+        confirmations,
+        dagExecutionReceipts,
+        interviews,
+        assessments,
+        chatRouteDeps,
+        chatOperationLinker,
+        chatRuntime,
+        nightAuxTicker,
+        actionContext,
+        observeRouteContext,
+        getReadiness,
+        refreshReadiness,
+        recoverDeferredTurns: () => recoverDeferredTurns(chatRouteDeps),
+        dispose: () => {
+            if (disposed)
+                return;
+            disposed = true;
+            try {
+                chatOperationLinker.dispose();
+            }
+            catch {
+                // best-effort
+            }
+            try {
+                chatRuntime.disposeAll();
+            }
+            catch {
+                // best-effort
+            }
+            try {
+                nightAuxTicker.dispose();
+            }
+            catch {
+                // best-effort
+            }
+        },
+    };
+    return context;
+}
+/** Inspect-facing readiness/capability summary for a registry record. */
+export async function summarizeWorkspaceRecord(record, deps) {
+    let state;
+    try {
+        const report = await probePiReadiness({
+            override: deps.piReadinessProbe,
+            repoRoot: record.repoRoot,
+        });
+        state = report.state;
+    }
+    catch {
+        state = "setup-required";
+    }
+    return {
+        state,
+        summary: `pi=${state}; inspect=${deps.inspectReady ? "ready" : "unavailable"}`,
+    };
+}
+void existsSync;

package/dist/worker/console/workspace-registry.js

@@ -0,0 +1,214 @@
+/**
+ * User-level Workspace Registry (2026-08-22 multi-workspace foundation, W1).
+ *
+ * Persists the set of registered Console workspaces at
+ * `<appDataRoot>/workspaces.json` (user level, shared across Console boots),
+ * independent of per-repo fingerprint namespaces.
+ *
+ * Invariants:
+ *   - workspaceId is stable per normalized realpath: it is derived from
+ *     sha256("loop-console-workspace-v1\0" + realpath) and never minted twice.
+ *   - REMOVE is soft (hidden=true); on-disk directories, AppData namespaces,
+ *     Sessions, Operations and DAGs are never deleted.
+ *   - Re-adding a previously removed workspace RESTORES the original record
+ *     (same workspaceId + repoFingerprint; only lastAccessedAt advances).
+ *   - Duplicate visible realpath is rejected; add failures leave the registry
+ *     byte-identical (same ids and order).
+ */
+import { createHash, randomBytes } from "node:crypto";
+import { realpathSync, statSync } from "node:fs";
+import path from "node:path";
+import { readJsonIfExists, writeSecureJson, } from "./app-data.js";
+import { normalizeWorktreeRealpath, repoFingerprintV1, } from "./repo-fingerprint.js";
+export const WORKSPACE_REGISTRY_SCHEMA_VERSION = 1;
+/** Stable workspaceId: sha256("loop-console-workspace-v1\0" + normalizedRealpath). */
+export function workspaceIdForRealpath(normalizedRealpath) {
+    return createHash("sha256")
+        .update(`loop-console-workspace-v1\0${normalizedRealpath}`, "utf8")
+        .digest("hex");
+}
+export class WorkspaceRegistry {
+    appData;
+    options;
+    file;
+    cache;
+    constructor(appData, options = {}) {
+        this.appData = appData;
+        this.options = options;
+        this.file = path.join(appData.root, "workspaces.json");
+    }
+    /** Auto-register the startup repoRoot (idempotent). */
+    async ensureStartupWorkspace(repoRoot) {
+        const record = await this.add(repoRoot);
+        if (record.ok)
+            return record.record;
+        // Startup root may already be visible (duplicate) or previously hidden —
+        // re-adding a hidden record restores it via add(); the only expected
+        // failure left is DUPLICATE (already visible), which returns the existing.
+        const existing = await this.findByRealpath(repoRoot);
+        if (existing)
+            return existing;
+        throw new Error(`workspace registry: startup root rejected: ${record.code}`);
+    }
+    /**
+     * Register (or restore) a workspace directory.
+     * Failures never mutate the persisted registry.
+     * `options.name` overrides the default directory-name label.
+     */
+    async add(rawPath, options = {}) {
+        const trimmed = rawPath.trim();
+        if (!trimmed) {
+            return {
+                ok: false,
+                code: "INVALID_PATH",
+                message: "path is required",
+            };
+        }
+        let real;
+        try {
+            real = realpathSync(path.resolve(trimmed));
+        }
+        catch {
+            return {
+                ok: false,
+                code: "NOT_A_DIRECTORY",
+                message: `path does not exist: ${trimmed}`,
+            };
+        }
+        let st;
+        try {
+            st = statSync(real);
+        }
+        catch {
+            return {
+                ok: false,
+                code: "UNREADABLE",
+                message: `path is not readable: ${trimmed}`,
+            };
+        }
+        if (!st.isDirectory()) {
+            return {
+                ok: false,
+                code: "NOT_A_DIRECTORY",
+                message: `path is not a directory: ${trimmed}`,
+            };
+        }
+        const normalized = normalizeWorktreeRealpath(real);
+        const existing = await this.findByRealpathNormalized(normalized);
+        if (existing && !existing.hidden) {
+            return {
+                ok: false,
+                code: "DUPLICATE",
+                message: `workspace already registered: ${existing.displayPath}`,
+            };
+        }
+        const nowIso = (this.options.now ?? (() => new Date()))().toISOString();
+        if (existing) {
+            // Restore the soft-removed record; identity (workspaceId,
+            // repoFingerprint, createdAt, order) is preserved.
+            existing.hidden = undefined;
+            existing.lastAccessedAt = nowIso;
+            if (options.name && options.name.trim()) {
+                existing.name = options.name.trim();
+            }
+            const registry = await this.load();
+            await this.persist(registry);
+            return { ok: true, record: existing, registryUnchanged: false };
+        }
+        const record = {
+            workspaceId: workspaceIdForRealpath(normalized),
+            name: options.name?.trim() || path.basename(normalized) || normalized,
+            displayPath: normalized,
+            repoRoot: real,
+            repoFingerprint: repoFingerprintV1(real),
+            createdAt: nowIso,
+            lastAccessedAt: nowIso,
+        };
+        const registry = await this.load();
+        registry.workspaces.push(record);
+        await this.persist(registry);
+        return { ok: true, record, registryUnchanged: false };
+    }
+    /** Visible list in canonical insertion order. */
+    async listVisible() {
+        const registry = await this.load();
+        return registry.workspaces.filter((workspace) => {
+            if (workspace.hidden)
+                return false;
+            try {
+                return statSync(workspace.repoRoot).isDirectory();
+            }
+            catch {
+                // Keep historical registry data, but do not project stale test roots
+                // into the Workspace browser after their directories disappear.
+                return false;
+            }
+        });
+    }
+    async get(workspaceId) {
+        const registry = await this.load();
+        return registry.workspaces.find((w) => w.workspaceId === workspaceId);
+    }
+    /** Get a VISIBLE workspace by id (removed workspaces are not operable). */
+    async getVisible(workspaceId) {
+        const record = await this.get(workspaceId);
+        if (!record || record.hidden)
+            return undefined;
+        try {
+            return statSync(record.repoRoot).isDirectory() ? record : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Soft-remove: hides the record; never touches directories or AppData. */
+    async remove(workspaceId) {
+        const registry = await this.load();
+        const record = registry.workspaces.find((w) => w.workspaceId === workspaceId);
+        if (!record || record.hidden)
+            return false;
+        record.hidden = true;
+        await this.persist(registry);
+        return true;
+    }
+    async findByRealpath(rawPath) {
+        let normalized;
+        try {
+            normalized = normalizeWorktreeRealpath(path.resolve(rawPath.trim()));
+        }
+        catch {
+            return undefined;
+        }
+        return this.findByRealpathNormalized(normalized);
+    }
+    async findByRealpathNormalized(normalized) {
+        const registry = await this.load();
+        return registry.workspaces.find((w) => w.displayPath === normalized);
+    }
+    async load() {
+        if (this.cache)
+            return this.cache;
+        const raw = await readJsonIfExists(this.file).catch(() => undefined);
+        const registry = {
+            schemaVersion: 1,
+            workspaces: raw && Array.isArray(raw.workspaces)
+                ? raw.workspaces.filter((w) => Boolean(w) &&
+                    typeof w === "object" &&
+                    typeof w.workspaceId === "string" &&
+                    typeof w.displayPath === "string" &&
+                    typeof w.repoRoot === "string")
+                : [],
+        };
+        this.cache = registry;
+        return registry;
+    }
+    async persist(registry) {
+        // writeSecureJson is atomic; a reader mid-write sees the previous bytes.
+        await writeSecureJson(this.file, registry);
+        this.cache = registry;
+    }
+}
+/** Deterministic-looking nonce reserved for tests requiring unique roots. */
+export function mintWorkspaceNonce() {
+    return randomBytes(8).toString("hex");
+}

package/dist/worker/observe/server.js

@@ -83,6 +83,10 @@ export function createObserveServer(options) {
                 url: `http://${host}:${addr.port}`,
                 close: () => new Promise((closeResolve, closeReject) => {
                     server.close((err) => (err ? closeReject(err) : closeResolve()));
+                    // Explicit shutdown must not wait for the 65s keep-alive window.
+                    // This also closes active SSE clients so process/test teardown is
+                    // deterministic instead of timing out behind pooled connections.
+                    server.closeAllConnections();
                 }),
             });
         });

package/dist/worker/observe/static/api.js

@@ -1,8 +1,12 @@
 /** Fetch and artifact helpers (Observe UI R5). */
+import {
+	fetchWithWorkspaceScope,
+	workspaceScope,
+} from "./state.js";
 
 export async function fetchJson(url) {
 	try {
-		const res = await fetch(url);
+		const res = await fetchWithWorkspaceScope(url);
 		if (!res.ok) return null;
 		return await res.json();
 	} catch {
@@ -18,7 +22,10 @@ export async function fetchJson(url) {
 export async function fetchJsonResult(url, options = {}) {
 	const signal = options?.signal;
 	try {
-		const res = await fetch(url, signal ? { signal } : undefined);
+		const res = await fetchWithWorkspaceScope(
+			url,
+			signal ? { signal } : undefined,
+		);
 		let body = null;
 		try {
 			body = await res.json();
@@ -92,7 +99,7 @@ export async function fetchDagNodeProcess(runId, nodeId, key) {
  */
 export async function fetchSpecEvidenceFile(runId, nodeId, source, relPath) {
 	const url = `/api/dag-runs/${encodeURIComponent(runId)}/nodes/${encodeURIComponent(nodeId)}/spec-evidence/file?source=${encodeURIComponent(source)}&path=${encodeURIComponent(relPath)}`;
-	const res = await fetch(url);
+	const res = await fetchWithWorkspaceScope(url);
 	let body = null;
 	try {
 		body = await res.json();
@@ -130,15 +137,28 @@ export async function postOperatorAction(action, actionParams = {}) {
 			body: { error: { code: "PROMPT_OVERRIDE_DISABLED", message: "提示词重启未启用（服务端未注入确认 token）" } },
 		};
 	}
+	const workspaceId = workspaceScope();
+	if (!workspaceId) {
+		return {
+			ok: false,
+			status: 400,
+			body: {
+				error: {
+					code: "WORKSPACE_REQUIRED",
+					message: "workspaceId is required",
+				},
+			},
+		};
+	}
 	try {
-		const res = await fetch("/api/operator/v1/operations", {
+		const res = await fetchWithWorkspaceScope("/api/operator/v1/operations", {
 			method: "POST",
 			credentials: "same-origin",
 			headers: {
 				"Content-Type": "application/json",
 				"x-loop-console-confirmation": token,
 			},
-			body: JSON.stringify({ action, actionParams }),
+			body: JSON.stringify({ workspaceId, action, actionParams }),
 		});
 		let body = null;
 		try {
@@ -155,7 +175,7 @@ export async function postOperatorAction(action, actionParams = {}) {
 /** Poll a Console operation snapshot (read-only GET). */
 export async function fetchOperatorOperation(operationId) {
 	try {
-		const res = await fetch(
+		const res = await fetchWithWorkspaceScope(
 			`/api/operator/v1/operations/${encodeURIComponent(operationId)}`,
 			{ credentials: "same-origin" },
 		);

package/dist/worker/observe/static/app.js

@@ -1,9 +1,8 @@
-/** Observe UI bootstrap: route wiring, listeners, compatibility re-exports. */
+/** Observe UI bootstrap: standalone compatibility entry + re-exports. */
 import {
 	parseHashRoute,
 	parseHashRouteWithFilters,
 	buildHashPath,
-	parseRoute,
 } from "./router.js";
 import { parseArtifactPreviewResponse } from "./api.js";
 import {
@@ -15,7 +14,6 @@ import {
 } from "./relations.js";
 import { copyText, renderRecommendedCommand } from "./copy.js";
 import {
-	isPageVisible,
 	detailPollDelay,
 	updateDagGraphViewportState,
 	captureDagGraphViewportState,
@@ -25,11 +23,9 @@ import {
 	shouldReuseDagDetailShell,
 	shouldPreserveDiagnosticsOpen,
 	isInteractiveGestureActive,
-	stopTimers,
 	renderViewState,
 	mountViewState,
 	viewStateDescriptor,
-	uiState,
 } from "./state.js";
 import { sortPoolTasks, poolStatusCounts } from "./format-pool.js";
 import {
@@ -45,34 +41,22 @@ import {
 	dashboardVisibleFeatures,
 	findDagForRun,
 } from "./dag-model.js";
-
-import { renderFailures } from "./views/failures.js";
-import { startPoolView } from "./views/pool.js";
-import { startDashboardPolling } from "./views/dashboard.js";
-import { startDagsView } from "./views/dags.js";
-import { renderFeatureDetail } from "./views/feature.js";
-import { renderBatch } from "./views/batch.js";
-import { startTaskPolling } from "./views/task.js";
-import { startRunPolling } from "./views/run.js";
-import { startDagPolling } from "./views/dag.js";
 import { renderDagGraph } from "./views/dag-graph.js";
-import { renderNightJobs } from "./views/night.js";
 import {
 	selectDagNode,
 	closeDagInspector,
-	closeDagInspectorOnOutsideClick,
 	renderDagInspector,
 } from "./views/dag-inspector.js";
 import {
 	mergeSessionEvents,
 	renderSessionTimeline,
 } from "./views/session-timeline.js";
-import { mountOperatorChrome } from "./operator-chrome.js";
+import {
+	route,
+	startStandaloneInspect,
+	tryCanonicalizeStandaloneInspect,
+} from "./inspect-workspace.js";
 
-// Compatibility re-exports for poll-stable UI helpers (owned by state.js / views):
-// reuse-dag-detail-shell, reuse-dag-graph-wrap, existingGraphWrap?.parentNode === ranksEl,
-// existingDetails?.parentNode === metaEl, let pre = existingPre, computeFollowLatest,
-// updateDagOutputViewportState, isInteractiveGestureActive.
 export {
 	detailPollDelay,
 	parseMarkdownBlocks,
@@ -114,56 +98,20 @@ export {
 	renderDagInspector,
 	renderSessionTimeline,
 	mergeSessionEvents,
+	route,
+	tryCanonicalizeStandaloneInspect,
 };
 
-function route() {
-	stopTimers();
-	const r = parseRoute();
-	if (r.view === "dashboard") {
-		startDashboardPolling(r.scrollTo);
-	} else if (r.view === "dags") {
-		void startDagsView();
-	} else if (r.view === "batch") {
-		void renderBatch(r.batchRunId);
-	} else if (r.view === "run") {
-		startRunPolling(r.workerRunId);
-	} else if (r.view === "dag") {
-		startDagPolling(r.dagRunId);
-	} else if (r.view === "failures") {
-		void renderFailures();
-	} else if (r.view === "pool") {
-		startPoolView();
-	} else if (r.view === "night") {
-		void renderNightJobs(r.scheduleId);
-	} else if (r.view === "task") {
-		startTaskPolling(r.featureId, r.taskId);
-	} else if (r.view === "feature") {
-		void renderFeatureDetail(r.featureId);
-	}
-}
-
 if (typeof window !== "undefined") {
-	// 先同步挂载共享壳，再启动路由；首个 snapshot 的新鲜度不会因异步挂载丢失。
-	const chromeHost = document.getElementById("operator-chrome");
-	if (chromeHost) {
-		mountOperatorChrome(chromeHost, {
-			mode: "inspect",
-			liveLocation: true,
-			healthUrl: "/api/health",
-			readinessTitle: "Pi 状态（只读展示）。模型与认证管理在操作侧，点击进入。",
-		});
+	// Compatibility listeners remain owned by inspect-workspace.js:
+	// window.addEventListener("hashchange", route)
+	// window.addEventListener("load", route)
+	// document.addEventListener("pointerdown", closeDagInspectorOnOutsideClick)
+	// document.addEventListener("visibilitychange", ...)
+	// reuse-dag-detail-shell, reuse-dag-graph-wrap, existingGraphWrap?.parentNode === ranksEl,
+	// existingDetails?.parentNode === metaEl, let pre = existingPre, computeFollowLatest,
+	// updateDagOutputViewportState, isInteractiveGestureActive.
+	if (!tryCanonicalizeStandaloneInspect(window.location)) {
+		startStandaloneInspect();
 	}
-	window.addEventListener("hashchange", route);
-	window.addEventListener("load", route);
-	document.addEventListener("pointerdown", closeDagInspectorOnOutsideClick);
-	document.addEventListener("visibilitychange", () => {
-		if (!isPageVisible()) return;
-		const r = parseRoute();
-		if (r.view === "dashboard") startDashboardPolling();
-		// History page is manual-refresh only (no 5s dashboard polling).
-		if (r.view === "run") startRunPolling(r.workerRunId, false);
-		if (r.view === "dag") startDagPolling(r.dagRunId, false);
-		if (r.view === "pool" && uiState.poolAutoRefresh) startPoolView();
-		if (r.view === "task") startTaskPolling(r.featureId, r.taskId);
-	});
 }

package/dist/worker/observe/static/index.html

@@ -210,7 +210,7 @@
               >
                 刷新
               </button>
-              <a class="page-action-btn" href="/#/night">在操作台管理 →</a>
+              <a class="page-action-btn" href="/#/operate/night">在操作台管理 →</a>
             </div>
           </header>
           <section