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

package/dist/worker/console/static-src/operator-chat/useComposer.js

@@ -7,7 +7,7 @@ import { attachRuntimeSnapshotController } from "./useRuntimeSnapshot.js";
 /** Composer state: input text, @file palette, image attachments, /shortcuts,
  *  IME composition guards, auto-grow and server-side draft sync. */
 export function useComposer(params) {
-    const { origin, sessionId, refs, setError } = params;
+    const { origin, sessionId, refs, setError, onUnrecoverableSession } = params;
     const [input, setInputState] = useState("");
     const [fileOptions, setFileOptions] = useState([]);
     const [pendingImages, setPendingImages] = useState([]);
@@ -28,6 +28,7 @@ export function useComposer(params) {
     }, []);
     const [shortcutIndex, setShortcutIndex] = useState(0);
     const [dynamicCommands, setDynamicCommands] = useState([]);
+    const [commandCapabilities, setCommandCapabilities] = useState({ sddBingo: false });
     const [dynamicCommandsLoading, setDynamicCommandsLoading] = useState(false);
     const [dynamicCommandsError, setDynamicCommandsError] = useState(null);
     const [commandsEpoch, setCommandsEpoch] = useState(0);
@@ -74,6 +75,7 @@ export function useComposer(params) {
         commandsSessionRef.current = sessionId;
         commandsGenerationRef.current += 1;
         setDynamicCommands([]);
+        setCommandCapabilities({ sddBingo: false });
         setDynamicCommandsError(null);
         setDynamicCommandsLoading(false);
     }, [sessionId]);
@@ -122,6 +124,7 @@ export function useComposer(params) {
             if (!isCurrent())
                 return;
             setDynamicCommands(items);
+            setCommandCapabilities({ sddBingo: body?.capabilities?.sddBingo === true });
             // Compact server fail-soft / partial-source warning; local Operator/Web still merge.
             const warning = typeof body?.warning === "string" ? body.warning.trim() : "";
             setDynamicCommandsError(warning ? warning.slice(0, 160) : null);
@@ -131,6 +134,7 @@ export function useComposer(params) {
                 return;
             setDynamicCommandsError("动态命令加载失败");
             setDynamicCommands([]);
+            setCommandCapabilities({ sddBingo: false });
         }
         finally {
             if (isCurrent()) {
@@ -227,7 +231,7 @@ export function useComposer(params) {
         }, 400);
         return () => window.clearTimeout(timer);
     }, [origin, sessionId, input]);
-    const mergedCommands = useMemo(() => mergeSlashCommands(dynamicCommands), [dynamicCommands]);
+    const mergedCommands = useMemo(() => mergeSlashCommands(dynamicCommands, commandCapabilities), [dynamicCommands, commandCapabilities]);
     const filteredShortcuts = useMemo(() => input.startsWith("/")
         ? filterSlashCommands(mergedCommands, input)
         : [], [input, mergedCommands]);
@@ -258,8 +262,13 @@ export function useComposer(params) {
     // origin + sessionId + refs in a writable file; the snapshot store is
     // consumed by ChatComposer / panels / runtime-context popover).
     useEffect(() => {
-        attachRuntimeSnapshotController({ origin, sessionId, refs });
-    }, [origin, sessionId, refs]);
+        attachRuntimeSnapshotController({
+            origin,
+            sessionId,
+            refs,
+            onUnrecoverableSession,
+        });
+    }, [origin, sessionId, refs, onUnrecoverableSession]);
     return {
         input,
         setInput,

package/dist/worker/console/static-src/operator-chat/useRuntimeControls.js

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { formatModelRef, mergeSessionRuntime, sessionRuntimeMatches, } from "../../chat/runtime-selection.js";
 import { confirmationToken } from "./format.js";
-import { mergeRuntimeContextWithSnapshot, runtimeSelectionFromSnapshot, } from "./runtime-snapshot-store.js";
+import { isLostChatSessionError, mergeRuntimeContextWithSnapshot, runtimeSelectionFromSnapshot, } from "./runtime-snapshot-store.js";
 import { buildToolCatalog } from "./tools-catalog.js";
 import { adoptMutationSnapshot, dispatchRuntimeSnapshot, getRuntimeSnapshotState, refreshRuntimeSnapshot, settleMutationLifecycle, useRuntimeSnapshot, } from "./useRuntimeSnapshot.js";
 /**
@@ -14,7 +14,7 @@ let mutationSeq = 0;
 /** Capabilities catalog, model / thinking-level switcher, runtime-context
  *  popover and the outside-click dismissal for both transient menus. */
 export function useRuntimeControls(params) {
-    const { origin, session, setSession, refs, setError } = params;
+    const { origin, session, setSession, refs, setError, onUnrecoverableSession } = params;
     const [capabilities, setCapabilities] = useState(null);
     const [models, setModels] = useState([]);
     const [modelsStatus, setModelsStatus] = useState("idle");
@@ -84,9 +84,20 @@ export function useRuntimeControls(params) {
             if (refs.sessionRef.current?.sessionId !== sessionId)
                 return;
             if (!res.ok || !body) {
+                const error = body
+                    ?.error;
+                if (isLostChatSessionError({
+                    status: res.status,
+                    code: error?.code,
+                    message: error?.message,
+                })) {
+                    setModelsStatus("idle");
+                    setModelsError(null);
+                    onUnrecoverableSession?.(sessionId);
+                    return;
+                }
                 setModelsStatus("error");
-                setModelsError(body
-                    ?.error?.message ?? `模型列表读取失败（HTTP ${res.status}）`);
+                setModelsError(error?.message ?? `模型列表读取失败（HTTP ${res.status}）`);
                 return;
             }
             setModels(body.models ?? []);
@@ -99,7 +110,7 @@ export function useRuntimeControls(params) {
             setModelsStatus("error");
             setModelsError(reason instanceof Error ? reason.message : String(reason));
         }
-    }, [origin, session, refs]);
+    }, [origin, session, refs, onUnrecoverableSession]);
     useEffect(() => {
         void loadModels();
     }, [loadModels]);
@@ -126,6 +137,18 @@ export function useRuntimeControls(params) {
             if (refs.sessionRef.current?.sessionId !== sessionId)
                 return;
             if (!body?.context) {
+                if (!r.ok &&
+                    isLostChatSessionError({
+                        status: r.status,
+                        code: body
+                            ?.error?.code,
+                        message: body
+                            ?.error?.message,
+                    })) {
+                    setRuntimeContextLoading(false);
+                    onUnrecoverableSession?.(sessionId);
+                    return;
+                }
                 if (!r.ok)
                     setRuntimeContextError("注入上下文读取失败，请重试");
                 return;
@@ -158,7 +181,7 @@ export function useRuntimeControls(params) {
                 return;
             setRuntimeContextError("注入上下文读取失败，请重试");
         });
-    }, [origin, session?.sessionId, refs]);
+    }, [origin, session?.sessionId, refs, onUnrecoverableSession]);
     // AC-01/RF3-01: hydrate the Composer from the unified snapshot — real
     // model and thinking selection; `auto` displays the Pi actual effective
     // level. Derived session/runtimeContext state ONLY comes from a snapshot

package/dist/worker/console/static-src/operator-chat/useRuntimeSnapshot.js

@@ -11,7 +11,7 @@
  */
 import { useSyncExternalStore } from "react";
 import { confirmationToken } from "./format.js";
-import { createRuntimeSnapshotStore, parseRuntimeSnapshotError, } from "./runtime-snapshot-store.js";
+import { createRuntimeSnapshotStore, isLostChatSessionError, parseRuntimeSnapshotError, } from "./runtime-snapshot-store.js";
 const store = createRuntimeSnapshotStore();
 let controller;
 function snapshotUrl(sessionId) {
@@ -49,10 +49,16 @@ async function fetchSnapshot(sessionId, origin) {
         if (controller?.sessionId !== sessionId)
             return; // stale session reply
         if (!res.ok) {
+            const error = { ...parseRuntimeSnapshotError(body), status: res.status };
+            if (isLostChatSessionError(error)) {
+                store.dispatch({ type: "reset" });
+                controller.onUnrecoverableSession?.(sessionId);
+                return;
+            }
             store.dispatch({
                 type: "load-failure",
                 sessionId,
-                error: { ...parseRuntimeSnapshotError(body), status: res.status },
+                error,
             });
             return;
         }

package/dist/worker/console/static-src/shell/console-update-reload.js

@@ -1,19 +1,46 @@
+export function isReplacementConsoleHealth(health, expectedConsoleInstanceId, previousConsoleInstanceId) {
+    if (!health || typeof health !== "object")
+        return false;
+    const instanceId = typeof health.consoleInstanceId ===
+        "string"
+        ? health.consoleInstanceId.trim()
+        : "";
+    if (!instanceId)
+        return false;
+    const expected = expectedConsoleInstanceId?.trim();
+    if (expected)
+        return instanceId === expected;
+    return previousConsoleInstanceId !== null && instanceId !== previousConsoleInstanceId;
+}
 /**
- * Poll /api/health until a (possibly brand-new) Console instance answers,
- * then reload. A handoff restart kills the old process before the new one
- * starts listening, so reloading immediately after "restarting" hits a dead
- * port and reads as "the page is gone".
+ * Poll /api/health until the replacement Console answers, then reload. A
+ * handoff deliberately leaves the old process alive briefly, so HTTP 200 alone
+ * is insufficient: the response must carry the new instance identity.
  */
-export async function reloadWhenConsoleReady(timeoutMs = 30_000) {
+export async function reloadWhenConsoleReady(options = {}) {
+    const timeoutMs = options.timeoutMs ?? 30_000;
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const reload = options.reload ?? (() => window.location.reload());
     const started = Date.now();
+    let previousConsoleInstanceId = null;
     while (Date.now() - started < timeoutMs) {
         try {
-            const res = await fetch(`/api/health?ts=${Date.now()}`, {
+            const res = await fetchImpl(`/api/health?ts=${Date.now()}`, {
                 cache: "no-store",
             });
             if (res.ok) {
-                window.location.reload();
-                return;
+                const health = await res.json().catch(() => null);
+                if (isReplacementConsoleHealth(health, options.expectedConsoleInstanceId, previousConsoleInstanceId)) {
+                    reload();
+                    return true;
+                }
+                const healthRecord = health;
+                const instanceId = typeof healthRecord?.consoleInstanceId === "string"
+                    ? healthRecord.consoleInstanceId.trim()
+                    : "";
+                if (instanceId && previousConsoleInstanceId === null) {
+                    previousConsoleInstanceId = instanceId;
+                }
             }
         }
         catch {
@@ -21,5 +48,5 @@ export async function reloadWhenConsoleReady(timeoutMs = 30_000) {
         }
         await new Promise((resolve) => setTimeout(resolve, 1000));
     }
-    window.location.reload();
+    return false;
 }

package/dist/worker/console/static-src/shell/workspace-route.js

@@ -170,6 +170,17 @@ export function withWorkspaceId(href, workspaceId) {
     const qs = query.toString();
     return `/#${path}${qs ? `?${qs}` : ""}`;
 }
+/** Preserve the selected scope for a deep link emitted inside an Operate page.
+ * Components should prefer this to hand-writing `/#/inspect/...`: it reads the
+ * canonical hash at click/render time and intentionally leaves bare Chat URLs
+ * unchanged because Chat selection is client state. */
+export function withCurrentWorkspaceId(href, locationLike = typeof globalThis.location === "undefined" ? undefined : globalThis.location) {
+    const { query } = splitHash(locationLike?.hash ?? "");
+    const workspaceId = query.get("workspaceId")?.trim() ||
+        new URLSearchParams(locationLike?.search ?? "").get("workspaceId")?.trim() ||
+        undefined;
+    return withWorkspaceId(href, workspaceId);
+}
 export function buildCanonicalHref(input) {
     if (input.workspace === "chat")
         return buildChatHref(input);

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

@@ -19,9 +19,10 @@
  */
 import { randomBytes } from "node:crypto";
 import { existsSync } from "node:fs";
+import { rm } from "node:fs/promises";
 import path from "node:path";
 import { LoopAgentClient } from "../loop-agent/loop-agent-client.js";
-import { openConsoleAppData, } from "../../infrastructure/console/app-data.js";
+import { openConsoleAppData, sha256Json, writeSecureJson, } from "../../infrastructure/console/app-data.js";
 import { DagConfirmationStore } from "./dag-confirmation.js";
 import { DagExecutionReceiptStore } from "./dag-execution-receipt.js";
 import { DraftStore } from "./draft-store.js";
@@ -31,6 +32,7 @@ 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 { AimaxAuthReader, SddDataAlignmentService } from "./chat/sdd-data-alignment.js";
 import { UserQuestionRegistry } from "./chat/user-questions.js";
 import { TodoListRegistry } from "./chat/todos.js";
 import { GoalRegistry } from "./chat/goals.js";
@@ -38,6 +40,9 @@ import { GoalRoundDriver } from "./chat/goal-round-driver.js";
 import { driveGoalRound, recoverDeferredTurns } from "./chat/routes.js";
 import { createOperationEventStore, } from "./operation-sse.js";
 import { OperationStore } from "../../infrastructure/console/operation-store.js";
+import { createFrontendSplitOperationAdapter, } from "./frontend-split-operation-adapter.js";
+import { createFrontendHumanDecisionAdapter } from "./frontend-human-decision-adapter.js";
+import { FrontendSplitTaskMaterializer, } from "../materialize/frontend-split-task-materializer.js";
 import { reconcileContextExports } from "../../infrastructure/console/context-export-store.js";
 import { reconcileArtifactRevisions } from "../../infrastructure/console/artifact-revision-store.js";
 import { recordContextTransferEvent } from "./context-transfer-diagnostics.js";
@@ -76,6 +81,106 @@ export async function createWorkspaceContext(record, deps) {
     const events = createOperationEventStore({
         persistenceDir: path.join(appData.operations, "events"),
     });
+    // Frontend split runtime is repo-scoped: materialization, durable schedule
+    // intents, and aggregate closeout must use this workspace's app-data and
+    // OperationStore rather than the process startup workspace.
+    const splitScheduleDir = path.join(appData.root, "frontend-split-schedule");
+    const splitAuditDir = path.join(appData.root, "frontend-split-audit");
+    const splitAggregateDir = path.join(appData.root, "frontend-split-aggregate");
+    const splitMaterializationBackend = {
+        async ensureTask({ taskId }) {
+            return { taskId, complete: true };
+        },
+        async ensureOperation({ taskId, operationId, payloadDigest, request }) {
+            const action = request.kind === "child"
+                ? "frontendSplitChild"
+                : "frontendSplitIntegration";
+            const { operation } = await operations.ensureSplitMaterializedOperation({
+                operationId,
+                taskId,
+                action,
+                actionParams: request,
+                payloadHash: payloadDigest,
+            });
+            return {
+                taskId: operation.taskId ?? taskId,
+                operationId: operation.operationId,
+                complete: true,
+            };
+        },
+    };
+    const materializer = new FrontendSplitTaskMaterializer(splitMaterializationBackend);
+    const schedule = async (input) => {
+        const fact = {
+            schemaVersion: 1,
+            kind: "frontend-split-schedule-intent",
+            operationId: input.operationId,
+            generation: input.generation,
+            bindingDigest: input.bindingDigest,
+            recordedAt: new Date().toISOString(),
+        };
+        const name = `${sha256Json({
+            operationId: input.operationId,
+            generation: input.generation,
+            bindingDigest: input.bindingDigest,
+        })}.json`;
+        await writeSecureJson(path.join(splitScheduleDir, name), fact);
+    };
+    const auditStale = async (input) => {
+        const fact = {
+            schemaVersion: 1,
+            kind: "frontend-split-stale-audit",
+            operationId: input.operationId,
+            reason: input.reason,
+            fact: input.fact,
+            recordedAt: new Date().toISOString(),
+        };
+        await writeSecureJson(path.join(splitAuditDir, `${sha256Json(fact)}.json`), fact);
+    };
+    const prepareAggregate = async ({ operationId, aggregate, }) => {
+        const before = await operations.get(operationId);
+        if (!before) {
+            throw new Error(`cannot prepare aggregate: parent operation not found: ${operationId}`);
+        }
+        const aggregateFile = path.join(splitAggregateDir, `${aggregate.digest}.json`);
+        let parentRecordPath = "";
+        let wroteAggregate = false;
+        let wroteParent = false;
+        return {
+            committedRef: {
+                ref: aggregateFile,
+                digest: aggregate.digest,
+                commitState: "committed",
+            },
+            async commit(input) {
+                parentRecordPath = input.parentRecordPath;
+                await writeSecureJson(aggregateFile, {
+                    schemaVersion: 1,
+                    kind: "frontend-split-aggregate-closeout",
+                    operationId,
+                    aggregate,
+                });
+                wroteAggregate = true;
+                await writeSecureJson(input.parentRecordPath, input.parentRecord);
+                wroteParent = true;
+            },
+            async rollback() {
+                if (wroteAggregate)
+                    await rm(aggregateFile, { force: true });
+                if (wroteParent && parentRecordPath) {
+                    await writeSecureJson(parentRecordPath, before);
+                }
+            },
+        };
+    };
+    const splitOrchestrator = createFrontendSplitOperationAdapter({
+        store: operations,
+        materializer,
+        schedule,
+        auditStale,
+        prepareAggregate,
+    });
+    const humanDecisionAdapter = createFrontendHumanDecisionAdapter(operations);
     const drafts = new DraftStore(appData);
     const confirmations = new DagConfirmationStore(appData, deps.bootToken.confirmationToken);
     const dagExecutionReceipts = new DagExecutionReceiptStore(appData);
@@ -123,6 +228,9 @@ export async function createWorkspaceContext(record, deps) {
         client,
         operations,
         events,
+        splitOrchestrator,
+        humanDecisionAdapter,
+        materializer,
         drafts,
         confirmations,
         dagExecutionReceipts,
@@ -146,6 +254,7 @@ export async function createWorkspaceContext(record, deps) {
             }
         },
     });
+    const sddDataAlignment = new SddDataAlignmentService(chatStore, new AimaxAuthReader(), deps.fetchImpl);
     const chatEventEpoch = randomBytes(12).toString("hex");
     const chatEvents = createChatEventStore({
         appData,
@@ -184,6 +293,7 @@ export async function createWorkspaceContext(record, deps) {
         questionRegistry,
         todoRegistry,
         goalRegistry,
+        sddDataAlignment,
     });
     let chatRouteDeps;
     const goalRoundDriver = new GoalRoundDriver((sessionId) => driveGoalRound(chatRouteDeps, sessionId));
@@ -195,6 +305,7 @@ export async function createWorkspaceContext(record, deps) {
         questionRegistry,
         todoRegistry,
         goalRegistry,
+        sddDataAlignment,
         goalRoundDriver,
         operationLinker: chatOperationLinker,
         appData,
@@ -218,6 +329,9 @@ export async function createWorkspaceContext(record, deps) {
         client,
         operations,
         events,
+        splitOrchestrator,
+        humanDecisionAdapter,
+        materializer,
         drafts,
         confirmations,
         dagExecutionReceipts,

package/dist/worker/materialize/frontend-split-task-materializer.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { computeFrontendSplitDigest } from "../../workflows/dag/frontend-split-orchestrator.js";
+const idSchema = z.string().trim().min(1);
+const digestSchema = z.string().regex(/^[a-f0-9]{64}$/);
+const positiveIntegerSchema = z.number().int().positive();
+const pathSchema = z.string().trim().min(1);
+export const frontendSplitTaskMaterializationRequestSchema = z.object({
+    kind: z.enum(["child", "integration"]),
+    parentOperationId: idSchema,
+    manifestDigest: digestSchema,
+    generation: positiveIntegerSchema,
+    taskId: idSchema,
+    operationId: idSchema,
+    payloadDigest: digestSchema,
+    allowedPaths: z.array(pathSchema),
+    writeSet: z.array(pathSchema),
+    verifyRefs: z.array(idSchema),
+}).strict();
+export const frontendSplitTaskMaterializationResultSchema = z.object({
+    idempotencyKey: digestSchema,
+    requestDigest: digestSchema,
+    taskId: idSchema,
+    operationId: idSchema,
+}).strict();
+function identityPayload(request) {
+    return { kind: request.kind, parentOperationId: request.parentOperationId, manifestDigest: request.manifestDigest, generation: request.generation, taskId: request.taskId, operationId: request.operationId };
+}
+export class FrontendSplitTaskMaterializer {
+    backend;
+    completed = new Map();
+    inFlight = new Map();
+    constructor(backend) {
+        this.backend = backend;
+    }
+    async materialize(raw) {
+        const request = frontendSplitTaskMaterializationRequestSchema.parse(raw);
+        const idempotencyKey = computeFrontendSplitDigest(identityPayload(request));
+        const requestDigest = computeFrontendSplitDigest(request);
+        const existing = this.completed.get(idempotencyKey);
+        if (existing) {
+            if (existing.requestDigest !== requestDigest)
+                throw new Error("frontend split materialization payload drift");
+            return existing;
+        }
+        const pending = this.inFlight.get(idempotencyKey);
+        if (pending) {
+            const result = await pending;
+            if (result.requestDigest !== requestDigest)
+                throw new Error("frontend split materialization payload drift");
+            return result;
+        }
+        const promise = this.perform(request, idempotencyKey, requestDigest);
+        this.inFlight.set(idempotencyKey, promise);
+        try {
+            const result = await promise;
+            this.completed.set(idempotencyKey, result);
+            return result;
+        }
+        finally {
+            this.inFlight.delete(idempotencyKey);
+        }
+    }
+    async perform(request, idempotencyKey, requestDigest) {
+        const task = await this.backend.ensureTask({ idempotencyKey, taskId: request.taskId, payloadDigest: requestDigest, request });
+        if (!task.complete || task.taskId !== request.taskId)
+            throw new Error("frontend split task materialization incomplete or drifted");
+        const operation = await this.backend.ensureOperation({ idempotencyKey, taskId: request.taskId, operationId: request.operationId, payloadDigest: requestDigest, request });
+        if (!operation.complete || operation.taskId !== request.taskId || operation.operationId !== request.operationId)
+            throw new Error("frontend split operation materialization incomplete or drifted");
+        return frontendSplitTaskMaterializationResultSchema.parse({ idempotencyKey, requestDigest, taskId: request.taskId, operationId: request.operationId });
+    }
+}

package/dist/worker/observe/routes.js

@@ -278,6 +278,10 @@ export async function serveObserveStatic(req, res, staticDir, options = {}) {
         "Content-Length": content.byteLength,
         "X-Content-Type-Options": "nosniff",
         "X-Frame-Options": "SAMEORIGIN",
+        // Filenames are unhashed and Console/observe builds change in place;
+        // heuristic caching would let a stale operator-chrome.js (old nav,
+        // old capabilities) survive a Console restart/update.
+        "Cache-Control": "no-store",
     };
     if (contentType.startsWith("text/html") && options.htmlEnhancer) {
         const enhanced = options.htmlEnhancer(Buffer.from(content));

package/dist/worker/observe/static/dag-helpers.js

@@ -6,7 +6,7 @@ import {
 	formatDuration,
 	formatAgo,
 } from "./format.js";
-import { navigate } from "./router.js";
+import { inspectPathToCanonicalHref, navigate } from "./router.js";
 
 export function isNodeActive(status) {
 	if (!status) return false;
@@ -151,7 +151,9 @@ export function frontendLintSummary(frontendLint) {
 	card.appendChild(meta);
 
 	const link = el("a", "active-dag-link", UI_TEXT.enterDetail);
-	link.href = `#/dag/${encodeURIComponent(dag.dagRunId)}`;
+	link.href = inspectPathToCanonicalHref(
+		`/dag/${encodeURIComponent(dag.dagRunId)}`,
+	);
 	link.addEventListener("click", (e) => {
 		e.preventDefault();
 		navigate(`/dag/${encodeURIComponent(dag.dagRunId)}`);

package/dist/worker/observe/static/dag-node-purpose.js

@@ -39,20 +39,25 @@ const NODE_PURPOSE_BY_ID = {
 	"closeout-summary-pi": "把验证与交付事实写成简短交接摘要。",
 
 	"frontend-contract-pi": "把前端需求整理成可追踪契约：页面、状态、验收与边界。",
+	"frontend-contract-import-shell": "导入并固化前端实现契约，供后续设计、写入与验证节点使用。",
 	"frontend-scout-pi": "只读侦察前端结构、组件与接口用法，不改文件。",
 	"frontend-plan-pi": "选定实现与 Mock/API 策略，输出可执行的前端实现契约补丁。",
+	"frontend-design-policy-shell": "确定前端设计与 Mock/API 策略，冻结后续实现必须遵守的规则。",
 	"frontend-design-review-pi": "审查前端计划是否可写：通过则沿用原计划，否则要求修订。",
 	"frontend-plan-revision-pi": "按设计审查意见修订前端契约，不扩大范围。",
 	"frontend-final-design-review-pi": "复核修订后的前端计划，只有通过才能授权写入。",
 	"frontend-prewrite-gate-shell": "写入前门禁：核对契约、覆盖与 Mock 策略，通过才允许改前端。",
+	"frontend-writer-admission-shell": "核对契约、设计策略与 writeSet，满足准入条件后才允许 writer 写入。",
 	"frontend-lint-baseline-shell": "记录写入前的 lint 基线，供实现后对比，不阻断写入。",
 	"frontend-implement-pi": "按已批准契约改前端代码、状态与交互，留在 writeSet 内。",
 	"frontend-verify-assess-shell": "跑静态/行为/Mock 验证并评估能否有界修复。",
+	"frontend-verify-shell": "执行冻结的前端验证命令，产出可复查的通过或失败证据。",
 	"frontend-repair-pi": "只修评估为可修复的前端失败，不重开需求。",
 	"frontend-reverify-shell": "修复后用同一套冻结命令复验。",
 	"frontend-review-context-shell": "打包真实 diff 与有效验证证据，供审查节点使用。",
 	"frontend-review-pi": "对照契约审查前端实现与证据，给出通过或需修订。",
 	"frontend-review-gate-shell": "前端审查门禁：结论为通过才进入收口。",
+	"frontend-closeout-shell": "汇总实现、验证与遗留事项，形成确定性的前端收口事实。",
 	"frontend-closeout-pi": "汇总前端交付状态（含真实联调是否仍待完成）。",
 	"frontend-mock-assess-pi": "评估项目是否具备授权的 Mock 验证能力。",
 	"frontend-mock-contract-gate-shell": "Mock 契约门禁：策略与验证命令不一致则阻断。",

package/dist/worker/observe/static/inspect-workspace.js

@@ -10,6 +10,7 @@ import {
 	parseRoute,
 	setNavigateHandler,
 	inspectPathToCanonicalHref,
+	workspaceIdFromLocation,
 } from "./router.js";
 import {
 	isPageVisible,
@@ -93,6 +94,25 @@ function onInspectRootClick(event) {
 	navigateInspectPath(href);
 }
 
+/** Static Inspect markup still contains a few compatibility anchors. Normalize
+ * them on mount/route change so opening a link in a new tab preserves the
+ * workspace as reliably as an ordinary in-app click. Chat remains deliberately
+ * bare: its selected workspace is client state, not a hash contract. */
+function scopeInspectShellLinks(root, workspaceId) {
+	if (!root?.querySelectorAll) return;
+	for (const anchor of root.querySelectorAll("a[href]")) {
+		const href = anchor.getAttribute("href");
+		if (!href || href.startsWith("/#/chat") || href.startsWith("#/chat")) {
+			continue;
+		}
+		if (!isInspectShellHref(href)) continue;
+		anchor.setAttribute(
+			"href",
+			inspectPathToCanonicalHref(href, workspaceId),
+		);
+	}
+}
+
 function resumeInspectPolling() {
 	if (!isPageVisible() || !isWorkspaceActive()) return;
 	const r = lastInspectHash
@@ -187,6 +207,7 @@ export function startStandaloneInspect() {
 	if (typeof window === "undefined") return;
 	// Multi-workspace (AC-003): sync scope from the URL query before any fetch.
 	syncWorkspaceScopeFromLocation();
+	scopeInspectShellLinks(document, workspaceIdFromLocation());
 	window.addEventListener("hashchange", syncWorkspaceScopeFromLocation);
 	const chromeHost = document.getElementById("operator-chrome");
 	if (chromeHost) {
@@ -242,6 +263,7 @@ export function mountInspectWorkspace(root, options = {}) {
 
 	setNavigateHandler(onNavigate);
 	lastInspectHash = options.hash || (typeof location !== "undefined" ? location.hash : "");
+	scopeInspectShellLinks(root, workspaceIdFromHash(lastInspectHash));
 	setWorkspaceActive(options.active !== false);
 
 	const listenerAbort =
@@ -266,6 +288,7 @@ export function mountInspectWorkspace(root, options = {}) {
 		updateRoute(hashValue) {
 			if (host.destroyed) return;
 			lastInspectHash = hashValue || lastInspectHash;
+			scopeInspectShellLinks(root, workspaceIdFromHash(lastInspectHash));
 			if (!uiState.workspaceActive) return;
 			// AC-006: a hosted route update that carries a DIFFERENT workspaceId
 			// must not route under the old scope. Swap atomically:

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

@@ -1,13 +1,13 @@
 /** KPI cards, projection fault, artifact/inbox links. */
 import { UI_TEXT } from "./constants.js";
 import { el } from "./dom.js";
-import { navigate } from "./router.js";
+import { inspectPathToCanonicalHref, navigate } from "./router.js";
 
 export function failuresInboxLink(count) {
 	const wrap = el("span", "kpi-value-with-link");
 	wrap.appendChild(el("span", "kpi-value-num", String(count)));
 	const a = el("a", "inbox-link", `${UI_TEXT.failureInbox} →`);
-	a.href = "#/failures";
+	a.href = inspectPathToCanonicalHref("/failures");
 	a.addEventListener("click", (e) => {
 		e.preventDefault();
 		navigate("/failures");

package/dist/worker/observe/static/operator-chrome.d.ts

@@ -62,10 +62,18 @@ export function parseInspectObjectView(
 export function activeInspectTabHref(hashValue: string): string | null;
 export function parseInspectContext(hashValue: string): InspectContext | null;
 export function resolveOperateHrefFromInspectHash(hashValue: string): string;
-export function buildOperateInterruptHref(dagRunId: string): string;
+export function buildOperateInterruptHref(
+	dagRunId: string,
+	options?: { workspaceId?: string | null },
+): string;
 export function buildInspectDagHref(
 	dagRunId: string,
-	options?: { from?: string },
+	options?: { from?: string; workspaceId?: string | null },
+): string;
+export function parseInspectWorkspaceId(hashValue: string): string | null;
+export function withWorkspaceQuery(
+	href: string,
+	workspaceId?: string | null,
 ): string;
 export function clearInspectContextSource(hashValue: string): string;
 export function repoBaseName(repoRoot: string): string;