@tea-agent/loop-agent 0.39.2 → 0.40.0-beta.1

package/dist/worker/observe/static/state.d.ts

@@ -0,0 +1,50 @@
+/** 与 state.js 对应的类型声明（供 vitest/TS 侧导入契约测试）。 */
+
+export type ViewStateKind = "loading" | "empty" | "degraded" | "error";
+
+export type ViewStateDescriptor = {
+	kind: ViewStateKind;
+	className: string;
+	role: string | null;
+	ariaLive: string | null;
+	message: string;
+	detail: string | null;
+	messageClass: string | null;
+};
+
+export const uiState: {
+	lastSnapshot: unknown;
+	specEvidenceDetail: {
+		source: string;
+		path: string;
+		loading: boolean;
+		error: string | null;
+		data: unknown;
+		triggerId: string | null;
+	} | null;
+	dagNodeExecutionOutputCache: Map<string, unknown> | null;
+	[key: string]: unknown;
+};
+
+export function setWorkspaceScope(workspaceId: string | null): void;
+export function workspaceScope(): string | null;
+export function scopedApiUrl(url: string): string;
+export function workspaceRequestSignal(): AbortSignal | undefined;
+export function fetchWithWorkspaceScope(
+	url: string,
+	init?: RequestInit,
+): Promise<Response>;
+export function abortWorkspaceRequests(): void;
+export function setWorkspaceActive(active: boolean): void;
+export function stopTimers(): void;
+export function pauseForegroundTimers(): void;
+
+/** Multi-workspace atomic scope switch (2026-08-26, AC-006). */
+export function applyWorkspaceScopeSwitch(
+	nextWorkspaceId: string | null,
+	routeValue?: (() => void) | string,
+	options?: {
+		route?: (hashValue: string) => void;
+		onTrace?: (trace: string[]) => void;
+	},
+): string[];

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

@@ -82,7 +82,9 @@ export const uiState = {
 	dagNodeExecutionOutputLoading: false,
 	dagNodeExecutionOutputError: null,
 	dagNodeExecutionOutputKey: null,
-	/** When true,「执行过程」展开 message_start/end 原始协议事件。默认隐藏，用户可点选展开。 */
+	/** Unified execution-record filter: all model/tool/process facts by default. */
+	executionRecordFilter: "all",
+	/** When true,「执行记录」展开 message_start/end 原始协议事件。默认隐藏，避免重复淹没语义记录。 */
 	sessionTimelineShowProtocol: false,
 	/** Open <details> keys restored across timeline re-renders. */
 	sessionTimelineOpenDetails: null,
@@ -116,6 +118,8 @@ export const uiState = {
 	/** Last-rendered spec-evidence list, used to restore the list synchronously. */
 	specEvidenceListEvidence: null,
 	pollingGeneration: 0,
+	/** Hosted Inspect workspace is foreground. Standalone defaults to active. */
+	workspaceActive: true,
 };
 
 /** Per-dagRunId graph viewport restore map (stable Map instance). */
@@ -279,16 +283,186 @@ export function isPageVisible() {
 	);
 }
 
+export function isWorkspaceActive() {
+	return uiState.workspaceActive !== false;
+}
+
+export function setWorkspaceActive(active) {
+	uiState.workspaceActive = Boolean(active);
+}
+
+/**
+ * Multi-workspace scope (2026-08-23): every Observe GET must carry the
+ * current workspaceId (AC-002/AC-003). The scope is synced from the parent
+ * Console shell hash (`?workspaceId=`) or via postMessage for hosted mode;
+ * standalone pages default to null and all workspace-scoped routes fail closed
+ * until the host or hash publishes an explicit workspace id.
+ */
+let currentWorkspaceScope = null;
+let currentWorkspaceRequestController =
+	typeof AbortController === "undefined" ? null : new AbortController();
+
+export function setWorkspaceScope(workspaceId) {
+	currentWorkspaceScope =
+		typeof workspaceId === "string" && workspaceId.trim()
+			? workspaceId.trim()
+			: null;
+}
+
+export function workspaceScope() {
+	return currentWorkspaceScope;
+}
+
+/** Signal shared by every workspace-scoped Observe request in the active scope. */
+export function workspaceRequestSignal() {
+	if (
+		typeof AbortController !== "undefined" &&
+		(!currentWorkspaceRequestController ||
+			currentWorkspaceRequestController.signal.aborted)
+	) {
+		currentWorkspaceRequestController = new AbortController();
+	}
+	return currentWorkspaceRequestController?.signal;
+}
+
+function combinedRequestSignal(scopeSignal, requestSignal) {
+	const signals = [scopeSignal, requestSignal].filter(Boolean);
+	if (signals.length <= 1) return { signal: signals[0], cleanup: () => {} };
+	const controller = new AbortController();
+	const abort = () => controller.abort();
+	for (const signal of signals) {
+		if (signal.aborted) abort();
+		else signal.addEventListener("abort", abort, { once: true });
+	}
+	return {
+		signal: controller.signal,
+		cleanup: () => {
+			for (const signal of signals) signal.removeEventListener("abort", abort);
+		},
+	};
+}
+
+/** Fetch through the current workspace boundary and abort on any scope swap. */
+export async function fetchWithWorkspaceScope(url, init = {}) {
+	const { signal: requestSignal, ...rest } = init;
+	const combined = combinedRequestSignal(
+		workspaceRequestSignal(),
+		requestSignal,
+	);
+	try {
+		return await fetch(scopedApiUrl(url), {
+			...rest,
+			...(combined.signal ? { signal: combined.signal } : {}),
+		});
+	} finally {
+		combined.cleanup();
+	}
+}
+
+/** Abort every old-scope request and invalidate request identity guards. */
+export function abortWorkspaceRequests() {
+	currentWorkspaceRequestController?.abort();
+	currentWorkspaceRequestController =
+		typeof AbortController === "undefined" ? null : new AbortController();
+	uiState.dagHistoryAbortController?.abort?.();
+	uiState.dagHistoryAbortController = null;
+	uiState.dagHistoryRequestSeq += 1;
+	uiState.dagHistoryPrefetchGeneration += 1;
+	uiState.dagNodeInputRequestSeq += 1;
+	uiState.dagNodeProcessRequestSeq += 1;
+	uiState.dagNodeExecutionOutputRequestSeq += 1;
+}
+
+/** Multi-workspace atomic scope switch (2026-08-26, AC-006).
+ *
+ * Contract order — strictly sequential, no interleaving:
+ *   1. abort old   — stop every poll/SSE so no late request can race the swap;
+ *   2. clear old   — drop cached run/task/selection state of the old scope;
+ *   3. set scope   — publish the new workspaceId for scopedApiUrl;
+ *   4. reload new  — re-route/re-render with the new scope active.
+ *
+ * Observability: each stage appends to the returned trace so tests (and
+ * diagnostics) can assert the exact ordering; there is no window in which a
+ * new route is requested with the old scope or vice versa.
+ */
+export function applyWorkspaceScopeSwitch(
+	nextWorkspaceId,
+	routeValue,
+	options = {},
+) {
+	const trace = [];
+	// 1. abort old
+	abortWorkspaceRequests();
+	stopTimers();
+	pauseForegroundTimers();
+	trace.push("abort-old");
+	// 2. clear old
+	uiState.lastSnapshot = null;
+	uiState.specEvidenceDetail = null;
+	uiState.specEvidenceListEvidence = null;
+	clearDagNodeExecutionOutputCache();
+	trace.push("clear-old");
+	// 3. set scope
+	setWorkspaceScope(nextWorkspaceId);
+	trace.push(`set-scope:${workspaceScope() ?? ""}`);
+	// 4. route/reload new
+	if (typeof routeValue === "function") routeValue();
+	else if (typeof routeValue === "string") options.route?.(routeValue);
+	trace.push("route-new");
+	if (options.onTrace) options.onTrace(trace);
+	return trace;
+}
+
+/** Append ?workspaceId= to an observe API URL (real request path kept). */
+export function scopedApiUrl(url) {
+	const raw = String(url ?? "");
+	if (!currentWorkspaceScope || !raw.startsWith("/api/")) return raw;
+	const qIndex = raw.indexOf("?");
+	if (qIndex >= 0) {
+		const params = new URLSearchParams(raw.slice(qIndex + 1));
+		if (params.has("workspaceId")) return raw;
+		params.set("workspaceId", currentWorkspaceScope);
+		return `${raw.slice(0, qIndex)}?${params.toString()}`;
+	}
+	return `${raw}?workspaceId=${encodeURIComponent(currentWorkspaceScope)}`;
+}
+
 export function detailPollDelay(status, isVisible) {
 	const normalizedStatus = (status ?? "").toLowerCase().replace(/-/g, "_");
 	if (TERMINAL_RUN_STATUSES.has(normalizedStatus)) return null;
+	if (!isWorkspaceActive()) return null;
 	return isVisible ? ACTIVE_DETAIL_POLL_MS : HIDDEN_POLL_MS;
 }
 
 export function dashboardPollDelay() {
+	if (!isWorkspaceActive()) return null;
 	return isPageVisible() ? DASHBOARD_POLL_MS : HIDDEN_POLL_MS;
 }
 
+/** Stop pausable timers without destroying route/selection/scroll. */
+export function pauseForegroundTimers() {
+	if (uiState.dashboardTimer) {
+		clearTimeout(uiState.dashboardTimer);
+		uiState.dashboardTimer = null;
+	}
+	if (uiState.runPollTimer) {
+		clearTimeout(uiState.runPollTimer);
+		uiState.runPollTimer = null;
+	}
+	if (uiState.dagPollTimer) {
+		clearTimeout(uiState.dagPollTimer);
+		uiState.dagPollTimer = null;
+	}
+	if (uiState.poolTimer) {
+		clearTimeout(uiState.poolTimer);
+		uiState.poolTimer = null;
+	}
+	if (uiState.taskPollTimer) {
+		clearTimeout(uiState.taskPollTimer);
+		uiState.taskPollTimer = null;
+	}
+}
+
 export function updateDagGraphViewportState(
 	_previous,
 	dagRunId,