@tea-agent/loop-agent 0.40.0-next.1 → 0.40.0-next.10

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

@@ -0,0 +1,46 @@
+/** 与 router.js 对应的类型声明（供 vitest/TS 侧导入契约测试）。 */
+
+export type InspectHashRoute = {
+	view: string;
+	batchRunId?: string;
+	workerRunId?: string;
+	dagRunId?: string;
+	featureId?: string;
+	taskId?: string;
+	scheduleId?: string;
+	page?: number;
+	pageSize?: number;
+	filters?: { status?: string; q?: string };
+};
+
+export function parseHashRoute(hashValue: string): InspectHashRoute;
+export function parseRoute(): InspectHashRoute;
+export function setNavigateHandler(
+	handler: ((href: string) => void) | null,
+): void;
+export function inspectPathToCanonicalHref(path: string): string;
+export function navigate(path: string): void;
+
+export const DAG_HISTORY_DEFAULT_PAGE: number;
+export const DAG_HISTORY_DEFAULT_PAGE_SIZE: number;
+export const DAG_HISTORY_ALLOWED_PAGE_SIZES: readonly number[];
+
+export function clampDagHistoryPageSize(value: unknown): number;
+export function clampDagHistoryPage(
+	value: unknown,
+	totalPages?: number,
+): number;
+export function parseDagHistoryQuery(hashValue: string): {
+	page: number;
+	pageSize: number;
+};
+export function buildDagHistoryHash(page: unknown, pageSize: unknown): string;
+export function parseHashFilters(hashValue: string): {
+	status?: string;
+	q?: string;
+};
+export function parseHashRouteWithFilters(hashValue: string): InspectHashRoute;
+export function buildHashPath(
+	path: string,
+	filters?: Record<string, unknown>,
+): string;

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

@@ -1,7 +1,10 @@
 /** Hash routing for Observe UI (R5). */
 
 export function parseHashRoute(hashValue) {
-	const hash = (hashValue.replace(/^#/, "") || "/").split("?")[0] || "/";
+	let hash = (hashValue.replace(/^#/, "") || "/").split("?")[0] || "/";
+	if (!hash.startsWith("/")) hash = `/${hash}`;
+	if (hash === "/inspect") hash = "/";
+	else if (hash.startsWith("/inspect/")) hash = hash.slice("/inspect".length) || "/";
 	const batchMatch = /^\/batch\/([^/]+)$/.exec(hash);
 	if (batchMatch) {
 		return { view: "batch", batchRunId: decodeURIComponent(batchMatch[1]) };
@@ -61,7 +64,28 @@ export function parseRoute() {
 	return parseHashRouteWithFilters(location.hash);
 }
 
+let navigateHandler = null;
+
+export function setNavigateHandler(handler) {
+	navigateHandler = typeof handler === "function" ? handler : null;
+}
+
+export function inspectPathToCanonicalHref(path) {
+	const raw = String(path ?? "");
+	if (raw.startsWith("/#/inspect")) return raw;
+	if (raw.startsWith("#/inspect")) return `/${raw}`;
+	const stripped = raw.replace(/^#/, "");
+	const withSlash = stripped.startsWith("/") ? stripped : `/${stripped}`;
+	if (withSlash === "/inspect" || withSlash === "/") return "/#/inspect";
+	if (withSlash.startsWith("/inspect/")) return `/#${withSlash}`;
+	return `/#/inspect${withSlash}`;
+}
+
 export function navigate(path) {
+	if (navigateHandler) {
+		navigateHandler(inspectPathToCanonicalHref(path));
+		return;
+	}
 	location.hash = path.startsWith("#") ? path.slice(1) : path;
 }
 

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,8 +82,8 @@ export const uiState = {
 	dagNodeExecutionOutputLoading: false,
 	dagNodeExecutionOutputError: null,
 	dagNodeExecutionOutputKey: null,
-	/** When true,「执行过程」展开 message_start/end 原始协议事件。默认展开，用户可点选隐藏。 */
-	sessionTimelineShowProtocol: true,
+	/** When true,「执行过程」展开 message_start/end 原始协议事件。默认隐藏，用户可点选展开。 */
+	sessionTimelineShowProtocol: false,
 	/** Open <details> keys restored across timeline re-renders. */
 	sessionTimelineOpenDetails: null,
 	lastSnapshot: null,
@@ -116,6 +116,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 +281,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,