@tea-agent/loop-agent 0.32.0 → 0.32.1

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

@@ -0,0 +1,207 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { formatModelRef, mergeSessionRuntime, runtimeSelectionFromRecord, sessionRuntimeMatches, } from "../../chat/runtime-selection.js";
+import { confirmationToken } from "./format.js";
+import { buildToolCatalog } from "./tools-catalog.js";
+/** 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 [capabilities, setCapabilities] = useState(null);
+    const [models, setModels] = useState([]);
+    const [thinkingLevels, setThinkingLevels] = useState([]);
+    const [runtimeContext, setRuntimeContext] = useState(null);
+    const [toolsOpen, setToolsOpen] = useState(false);
+    const [runtimeContextOpen, setRuntimeContextOpen] = useState(false);
+    const toolsMenuRef = useRef(null);
+    const runtimeContextMenuRef = useRef(null);
+    const loadCapabilities = useCallback(async () => {
+        try {
+            const res = await fetch(`${origin}/api/operator/v1/chat/capabilities`);
+            if (!res.ok)
+                return;
+            const body = (await res.json());
+            setCapabilities(body);
+        }
+        catch {
+            // capabilities optional; Chat still works without them
+        }
+    }, [origin]);
+    useEffect(() => {
+        void loadCapabilities();
+    }, [loadCapabilities]);
+    useEffect(() => {
+        if (!session) {
+            setModels([]);
+            setRuntimeContext(null);
+            return;
+        }
+        const sessionId = session.sessionId;
+        const base = `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}`;
+        void fetch(`${base}/models`, { credentials: "include" })
+            .then((r) => (r.ok ? r.json() : null))
+            .then((body) => {
+            // Guard against a stale response landing after the user switched/
+            // created/forked a session: only adopt models for the session we
+            // actually requested them for.
+            if (!body || refs.sessionRef.current?.sessionId !== sessionId)
+                return;
+            setModels(body.models ?? []);
+            setThinkingLevels(body.thinkingLevels ?? []);
+        });
+        void fetch(`${base}/runtime-context`, { credentials: "include" })
+            .then((r) => (r.ok ? r.json() : null))
+            .then((body) => {
+            // Stale-response guard: a slow runtime-context reply for session A
+            // must not overwrite the context/session state of the now-current
+            // session B.
+            if (!body?.context || refs.sessionRef.current?.sessionId !== sessionId)
+                return;
+            setRuntimeContext(body.context);
+            const ctx = body.context;
+            const patch = {
+                model: ctx.model,
+                thinkingLevel: ctx.thinkingLevel,
+            };
+            setSession((current) => {
+                if (!current || current.sessionId !== sessionId)
+                    return current;
+                if (sessionRuntimeMatches(current, patch))
+                    return current;
+                const merged = mergeSessionRuntime(current, patch);
+                refs.sessionRef.current = merged;
+                return merged;
+            });
+        });
+    }, [origin, session?.sessionId, refs, setSession]);
+    const switchRuntime = useCallback(async (body) => {
+        if (!session)
+            return;
+        // Capture the target session so a slow model/thinking response cannot
+        // write its result into a different (newly created/forked/switched)
+        // session the user has since moved to.
+        const targetSessionId = session.sessionId;
+        const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(session.sessionId)}/model`, {
+            method: "POST",
+            credentials: "include",
+            headers: {
+                "content-type": "application/json",
+                "x-loop-console-confirmation": confirmationToken(),
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            // Only surface the failure for the session that still owns it.
+            if (refs.sessionRef.current?.sessionId === targetSessionId)
+                setError("模型或思考等级切换失败");
+            return;
+        }
+        const payload = (await res.json().catch(() => ({})));
+        if (!payload.session)
+            return;
+        // Drop the result entirely if the active session changed mid-flight.
+        if (refs.sessionRef.current?.sessionId !== targetSessionId)
+            return;
+        setSession((current) => {
+            if (!current || current.sessionId !== targetSessionId)
+                return current;
+            const patch = runtimeSelectionFromRecord(payload.session);
+            if (sessionRuntimeMatches(current, patch))
+                return current;
+            const merged = mergeSessionRuntime(current, patch);
+            refs.sessionRef.current = merged;
+            return merged;
+        });
+        setRuntimeContext((current) => current
+            ? {
+                ...current,
+                ...(payload.session.modelProvider && payload.session.modelId
+                    ? {
+                        model: {
+                            provider: payload.session.modelProvider,
+                            modelId: payload.session.modelId,
+                        },
+                    }
+                    : {}),
+                ...(payload.session.thinkingLevel
+                    ? { thinkingLevel: payload.session.thinkingLevel }
+                    : body.thinkingLevel
+                        ? { thinkingLevel: body.thinkingLevel }
+                        : {}),
+            }
+            : current);
+    }, [origin, session, refs, setSession, setError]);
+    // Close tools catalog on outside click / Escape.
+    useEffect(() => {
+        if (!toolsOpen)
+            return;
+        const onPointer = (e) => {
+            const root = toolsMenuRef.current;
+            if (!root)
+                return;
+            if (e.target instanceof Node && !root.contains(e.target)) {
+                setToolsOpen(false);
+            }
+        };
+        const onKey = (e) => {
+            if (e.key === "Escape")
+                setToolsOpen(false);
+        };
+        document.addEventListener("mousedown", onPointer);
+        document.addEventListener("keydown", onKey);
+        return () => {
+            document.removeEventListener("mousedown", onPointer);
+            document.removeEventListener("keydown", onKey);
+        };
+    }, [toolsOpen]);
+    // Close runtime-context popover on outside click / Escape.
+    useEffect(() => {
+        if (!runtimeContextOpen)
+            return;
+        const onPointer = (e) => {
+            const root = runtimeContextMenuRef.current;
+            if (!root)
+                return;
+            if (e.target instanceof Node && !root.contains(e.target)) {
+                setRuntimeContextOpen(false);
+            }
+        };
+        const onKey = (e) => {
+            if (e.key === "Escape")
+                setRuntimeContextOpen(false);
+        };
+        document.addEventListener("mousedown", onPointer);
+        document.addEventListener("keydown", onKey);
+        return () => {
+            document.removeEventListener("mousedown", onPointer);
+            document.removeEventListener("keydown", onKey);
+        };
+    }, [runtimeContextOpen]);
+    const toolCatalog = useMemo(() => buildToolCatalog(capabilities), [
+        capabilities,
+    ]);
+    const activeModel = session?.model ?? runtimeContext?.model;
+    const activeModelRef = activeModel
+        ? formatModelRef(activeModel.provider, activeModel.modelId)
+        : "";
+    const activeThinkingLevel = session?.thinkingLevel ?? runtimeContext?.thinkingLevel ?? "";
+    const activeModelListed = !activeModelRef ||
+        models.some((model) => formatModelRef(model.provider, model.id) === activeModelRef);
+    return {
+        capabilities,
+        models,
+        thinkingLevels,
+        runtimeContext,
+        toolsOpen,
+        setToolsOpen,
+        runtimeContextOpen,
+        setRuntimeContextOpen,
+        toolsMenuRef,
+        runtimeContextMenuRef,
+        switchRuntime,
+        toolCatalog,
+        activeModel,
+        activeModelRef,
+        activeThinkingLevel,
+        activeModelListed,
+    };
+}

package/docs/templates/agent-worker-production-readiness-checklist.md

@@ -2,44 +2,46 @@
 
 用于 Phase 8 campaign / 发布门禁。勾选前必须有新鲜命令输出或 report ref。
 
+正式 pin（2026-08-09）：`@tea-agent/loop-agent@0.32.0`（tag `v0.32.0` / `b4d9e500`）。scorecard 在 burn-in / live 门禁完成前保持 **NOT_READY**。证据：`docs/reports/feature/2026-08-09-agent-worker-production-readiness-v1.md`。
+
 ## 包络与身份
 
-- [ ] 支持包络已冻结（单机/单用户/单仓）
-- [ ] controller packageVersion + fingerprint 已记录
-- [ ] 无 npm link / workspace bin 冒充正式 controller
-- [ ] protocol/capabilities preflight 通过
+- [x] 支持包络已冻结（单机/单用户/单仓）
+- [x] controller packageVersion + fingerprint 已记录（`0.32.0`；npm shasum `8932749b1583523043a9889c84f9d316e57e451d`；canary fingerprint `sha256:b08404f5…`）
+- [x] published canary / 隔离 install **无** npm link / workspace bin（live burn-in 仍须每日复核）
+- [x] protocol/capabilities preflight（unit）通过；live preflight 仍待
 
 ## Ownership / Attempt
 
-- [ ] Running 投影不依赖 terminal ledger
-- [ ] Task-scoped events 含 featureId
-- [ ] dual Feature 同名 Task 隔离
-- [ ] ownership warning 按根因聚合（≤1 finding/根因）
+- [x] Running 投影不依赖 terminal ledger（unit / Phase 1）
+- [x] Task-scoped events 含 featureId（unit）
+- [x] dual Feature 同名 Task 隔离（unit C2）
+- [x] ownership warning 按根因聚合（≤1 finding/根因）（unit）
 
 ## Lifecycle / Recovery
 
-- [ ] safe run-error → Failed → `task retry` 无需 mark-failed
-- [ ] Blocked 保留 contract/human 语义
-- [ ] resume / retry / reconcile / revise / decide 决策一致
+- [x] safe run-error → Failed → `task retry` 无需 mark-failed（unit）
+- [x] Blocked 保留 contract/human 语义（unit）
+- [x] resume / retry / reconcile / revise / decide 决策一致（unit）
 
 ## Lease
 
-- [ ] `{featureId, taskId}` 单 active writer
-- [ ] begin/finalize crash injection 有 doctor finding
-- [ ] 不盲目偷取 live DAG lease
+- [x] `{featureId, taskId}` 单 active writer（unit C3）
+- [ ] begin/finalize crash injection 有 doctor finding（进程级仍缺）
+- [x] 不盲目偷取 live DAG lease（unit reclaim）
 
 ## Acceptance / Delivery
 
-- [ ] Task Done ≠ AC covered
-- [ ] `feature verify-final` 唯一 writer
-- [ ] verify-final → delivery → closeout 可收口
-- [ ] dirty HEAD / tamper fail-closed
+- [x] Task Done ≠ AC covered（unit）
+- [x] `feature verify-final` 唯一 writer（unit）
+- [ ] verify-final → delivery → closeout **live** 可收口
+- [x] dirty HEAD / tamper fail-closed（unit）
 
 ## Campaign / SLO
 
-- [ ] C0–C11 已执行或明确 blocked-external
-- [ ] burn-in 窗口达标（7 日或 30 Attempt）
-- [ ] SLO 分子/分母已记录
-- [ ] promote + rollback drill 完成
-- [ ] scorecard: READY 或合法 CONDITIONALLY_READY
-- [ ] open P0 = 0
+- [x] C0–C11 已执行或明确 blocked-external（partial：unit + published canary；live Pi blocked）
+- [ ] burn-in 窗口达标（7 日或 30 Attempt）— **OPEN day 0**
+- [ ] SLO 分子/分母已记录（正式样本不足）
+- [x] promote + rollback drill 完成（install-level vs `0.31.1`）
+- [ ] scorecard: READY 或合法 CONDITIONALLY_READY — 当前 **`NOT_READY`**
+- [x] open P0 = 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.32.0",
+  "version": "0.32.1",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",
@@ -46,11 +46,12 @@
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
     "brand:sync": "node scripts/sync-brand-assets.mjs",
     "build": "npm run brand:sync && npm run clean && tsc -p tsconfig.build.json && node -e \"const fs=require('node:fs');const p='dist/worker/observe/static';fs.mkdirSync(p,{recursive:true});fs.cpSync('src/worker/observe/static',p,{recursive:true});\" && npm run console:build",
-    "console:build": "vite build --config src/worker/console/vite.config.ts",
+    "console:typecheck": "tsc -p src/worker/console/tsconfig.json",
+    "console:build": "npm run console:typecheck && vite build --config src/worker/console/vite.config.ts",
     "prepack": "npm run build",
     "prepublishOnly": "node scripts/check-npm-publish-policy.mjs && npm run typecheck && npm test && npm run build",
-    "lint": "tsc --noEmit",
-    "typecheck": "tsc --noEmit",
+    "lint": "npm run typecheck",
+    "typecheck": "tsc --noEmit && npm run console:typecheck",
     "test": "node scripts/run-tests.mjs",
     "test:host": "vitest run test/init-upgrade.test.ts --maxWorkers=1 -t \"records and reuses|controller-authorized semantic merge|authority-sensitive\"",
     "test:fast": "vitest run --config vitest.fast.config.ts",