@tea-agent/loop-agent 0.31.1 → 0.32.1

package/dist/worker/console/static-src/app/useTaskWizard.js

@@ -0,0 +1,229 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { ensureUniqueDocumentNames, operatorRequestFits, operatorRequestTooLargeMessage, } from "../prd-file-import.js";
+import { requestId, WORKFLOW_OPTIONS, } from "./console-types.js";
+/** Happy Path task wizard: import-prd → interview → contract → dag-confirm →
+ *  run. Owns task identity, interview projection and contract preflight/apply. */
+export function useTaskWizard(params) {
+    const { shell, actions, prd } = params;
+    const { step, setStep, setOpMessage } = shell;
+    const { runAction, isActionSuccess, summarizeEnvelope } = actions;
+    const [taskId, setTaskId] = useState("");
+    const [taskTitle, setTaskTitle] = useState("");
+    const [taskKind, setTaskKind] = useState("standard");
+    const workflowMeta = WORKFLOW_OPTIONS.find((w) => w.kind === taskKind) ?? WORKFLOW_OPTIONS[0];
+    const [sessionId, setSessionId] = useState(null);
+    const [question, setQuestion] = useState(null);
+    const [answerText, setAnswerText] = useState("");
+    const [draftSummary, setDraftSummary] = useState(null);
+    const [assessmentId, setAssessmentId] = useState(null);
+    const [contractValidateOk, setContractValidateOk] = useState(null);
+    const [contractValidateSummary, setContractValidateSummary] = useState(null);
+    const [contractDiffSummary, setContractDiffSummary] = useState(null);
+    const [contractApplied, setContractApplied] = useState(false);
+    const [spineOk, setSpineOk] = useState(null);
+    const [contractPreflightKey, setContractPreflightKey] = useState(null);
+    const contractPreflightRunning = useRef(false);
+    const resetContractLanding = useCallback(() => {
+        setContractValidateOk(null);
+        setContractValidateSummary(null);
+        setContractDiffSummary(null);
+        setContractApplied(false);
+        setSpineOk(null);
+        setContractPreflightKey(null);
+        contractPreflightRunning.current = false;
+    }, []);
+    const enterContractStep = useCallback(() => {
+        resetContractLanding();
+        setStep("contract");
+    }, [resetContractLanding, setStep]);
+    const applyInterviewPayload = useCallback((result) => {
+        const session = result.session;
+        if (session?.sessionId)
+            setSessionId(session.sessionId);
+        const q = result.question;
+        setQuestion(q);
+        setDraftSummary(result.summary ?? null);
+        const aid = result.assessmentId;
+        if (typeof aid === "string" && aid)
+            setAssessmentId(aid);
+        if (result.complete === true || (typeof aid === "string" && aid)) {
+            enterContractStep();
+            setOpMessage(result.skipped === true
+                ? "已跳过访谈：已按推荐补齐草稿并签发评估"
+                : "访谈已完成：草稿已绑定完整评估结果");
+        }
+    }, [enterContractStep, setOpMessage]);
+    const runContractPreflight = useCallback(async (force = false) => {
+        const id = taskId.trim();
+        if (!id)
+            return;
+        const key = `${id}:${assessmentId ?? ""}`;
+        if (!force &&
+            contractPreflightKey === key &&
+            contractValidateOk !== null) {
+            return;
+        }
+        if (contractPreflightRunning.current)
+            return;
+        contractPreflightRunning.current = true;
+        setContractValidateOk(null);
+        setContractValidateSummary(null);
+        setContractDiffSummary(null);
+        setSpineOk(null);
+        setContractApplied(false);
+        try {
+            const validateBody = await runAction("contractValidate", {
+                taskId: id,
+            });
+            const validateOk = isActionSuccess(validateBody);
+            setContractValidateOk(validateOk);
+            setContractValidateSummary(summarizeEnvelope(validateBody));
+            if (!validateOk) {
+                setContractPreflightKey(key);
+                setOpMessage("契约校验未通过：请先修正草稿后再应用");
+                return;
+            }
+            const diffBody = await runAction("contractDiff", { taskId: id });
+            setContractDiffSummary(summarizeEnvelope(diffBody));
+            setContractPreflightKey(key);
+            setOpMessage(isActionSuccess(diffBody)
+                ? "校验与差异已就绪：确认后可应用契约"
+                : "校验通过，但差异查询失败（仍可查看下方摘要）");
+        }
+        finally {
+            contractPreflightRunning.current = false;
+        }
+    }, [
+        assessmentId,
+        contractPreflightKey,
+        contractValidateOk,
+        isActionSuccess,
+        runAction,
+        setOpMessage,
+        summarizeEnvelope,
+        taskId,
+    ]);
+    const applyContractThenSpine = useCallback(async () => {
+        const id = taskId.trim();
+        if (!id || !assessmentId)
+            return;
+        const applyBody = await runAction("contractApply", { taskId: id, assessmentId }, { clientRequestId: requestId("apply") });
+        if (!isActionSuccess(applyBody)) {
+            setContractApplied(false);
+            return;
+        }
+        setContractApplied(true);
+        const spineBody = await runAction("spineCheck", { taskId: id });
+        if (isActionSuccess(spineBody)) {
+            setSpineOk(true);
+            setStep("dag-confirm");
+            setOpMessage("契约已应用并通过 Spine 审计，可生成并运行 DAG");
+            return;
+        }
+        setSpineOk(false);
+        setOpMessage("契约已应用，但 Spine 审计未通过：可重试 Spine");
+    }, [assessmentId, isActionSuccess, runAction, setOpMessage, setStep, taskId]);
+    const retrySpineOnly = useCallback(async () => {
+        const id = taskId.trim();
+        if (!id)
+            return;
+        const spineBody = await runAction("spineCheck", { taskId: id });
+        if (isActionSuccess(spineBody)) {
+            setSpineOk(true);
+            setStep("dag-confirm");
+            setOpMessage("Spine 审计已通过，可生成并运行 DAG");
+            return;
+        }
+        setSpineOk(false);
+    }, [isActionSuccess, runAction, setOpMessage, setStep, taskId]);
+    const confirmAndRunDag = useCallback(async () => {
+        const id = actions.confirmationId?.trim();
+        if (!id)
+            return;
+        // M0-B: pass the server-signed human-gate token (issued at prepare) instead
+        // of the old fixed-string challenge set. The dispatch layer verifies the
+        // HMAC signature, so the model cannot self-confirm.
+        const humanGateToken = actions.confirmationDetails?.confirmation?.humanGateToken;
+        const confirmBody = await runAction("confirmDagConfirmation", {
+            confirmationId: id,
+            humanGateToken,
+        });
+        if (!isActionSuccess(confirmBody))
+            return;
+        setStep("run");
+        await runAction("runDag", { confirmationId: id }, { clientRequestId: requestId("run") });
+    }, [
+        actions.confirmationId,
+        actions.confirmationDetails,
+        isActionSuccess,
+        runAction,
+        setStep,
+    ]);
+    useEffect(() => {
+        if (step !== "contract")
+            return;
+        if (!taskId.trim())
+            return;
+        void runContractPreflight(false);
+    }, [step, taskId, assessmentId, runContractPreflight]);
+    const importPrdAndCreate = useCallback(async () => {
+        const docsPayload = prd.prdDocuments.length > 0
+            ? ensureUniqueDocumentNames(prd.prdDocuments)
+            : undefined;
+        const actionParams = {
+            content: prd.prdText,
+            taskKind,
+            ...(docsPayload ? { documents: docsPayload } : {}),
+        };
+        if (!operatorRequestFits("bootstrapFromPrd", actionParams)) {
+            prd.setPrdFileError(operatorRequestTooLargeMessage());
+            return;
+        }
+        const body = await runAction("bootstrapFromPrd", actionParams);
+        if (!body || body.ok === false)
+            return;
+        const result = (body.result ?? {});
+        if (result.taskId)
+            setTaskId(result.taskId);
+        if (result.title)
+            setTaskTitle(result.title);
+        setOpMessage(`已创建任务「${result.title ?? ""}」（${result.taskId ?? ""}），来源：${result.identitySource ?? "prd"}`);
+        setStep("interview");
+    }, [prd, runAction, setOpMessage, setStep, taskKind]);
+    const wizardSteps = [
+        { id: "setup", label: "就绪检查" },
+        { id: "import-prd", label: "导入需求" },
+        { id: "interview", label: "需求访谈（可跳过）" },
+        { id: "contract", label: "契约落地" },
+        { id: "dag-confirm", label: "确认 DAG" },
+        { id: "run", label: "运行" },
+    ];
+    const stepIndex = wizardSteps.findIndex((s) => s.id === step);
+    return {
+        taskId,
+        setTaskId,
+        taskTitle,
+        taskKind,
+        setTaskKind,
+        workflowMeta,
+        sessionId,
+        question,
+        answerText,
+        setAnswerText,
+        draftSummary,
+        assessmentId,
+        contractValidateOk,
+        contractValidateSummary,
+        contractDiffSummary,
+        contractApplied,
+        spineOk,
+        applyInterviewPayload,
+        runContractPreflight,
+        applyContractThenSpine,
+        retrySpineOnly,
+        confirmAndRunDag,
+        importPrdAndCreate,
+        wizardSteps,
+        stepIndex,
+    };
+}

package/dist/worker/console/static-src/chat-view-types.js

@@ -0,0 +1,2 @@
+/** Sidebar keeps the N most recently updated sessions (active + archived). */
+export const CHAT_SESSION_LIST_LIMIT = 10;

package/dist/worker/console/static-src/night/night-types.js

@@ -0,0 +1,24 @@
+export function requestId(prefix) {
+    return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+export function confirmationToken() {
+    return window.__CONSOLE_CONFIRMATION_TOKEN__ ?? "";
+}
+export function statusLabel(status) {
+    const map = {
+        submitted: "已提交",
+        validating: "校验中",
+        validated: "待预约确认",
+        scheduled: "已预约",
+        waiting: "等待触发",
+        dispatching: "派发中",
+        running: "执行中",
+        succeeded: "成功",
+        failed: "失败",
+        human_required: "需人工",
+        cancelled: "已取消",
+        rejected: "已拒绝",
+        cancel_requested: "取消中",
+    };
+    return map[status] ?? status;
+}

package/dist/worker/console/static-src/night/useNightBoard.js

@@ -0,0 +1,125 @@
+import { useCallback, useEffect, useState } from "react";
+import { confirmationToken, } from "./night-types.js";
+/** Night board data plane: schedules list + doctor report + task pool +
+ *  foreground aux-ticker projection, loaded together on mount/refresh. */
+export function useNightBoard(params) {
+    const { setOpError } = params;
+    const [list, setList] = useState(null);
+    const [doctor, setDoctor] = useState(null);
+    const [tasks, setTasks] = useState([]);
+    const [loadError, setLoadError] = useState(null);
+    const [loadingBoard, setLoadingBoard] = useState(false);
+    const [advancedOpen, setAdvancedOpen] = useState(false);
+    const [morningPreview, setMorningPreview] = useState(null);
+    const [auxTicker, setAuxTicker] = useState(null);
+    const [auxTickerBusy, setAuxTickerBusy] = useState(false);
+    const refreshBoard = useCallback(async () => {
+        setLoadingBoard(true);
+        setLoadError(null);
+        try {
+            const [jobsRes, doctorRes, tasksRes, tickerRes] = await Promise.all([
+                fetch("/api/night-jobs", { credentials: "same-origin" }),
+                fetch("/api/night-jobs/doctor", { credentials: "same-origin" }),
+                fetch("/api/tasks", { credentials: "same-origin" }),
+                fetch("/api/operator/v1/night-aux-ticker", {
+                    credentials: "same-origin",
+                }),
+            ]);
+            if (!jobsRes.ok) {
+                throw new Error(`加载计划列表失败（HTTP ${jobsRes.status}）`);
+            }
+            const jobsBody = (await jobsRes.json());
+            setList(jobsBody);
+            if (doctorRes.ok) {
+                setDoctor((await doctorRes.json()));
+            }
+            else {
+                setDoctor(null);
+            }
+            if (tasksRes.ok) {
+                const taskBody = (await tasksRes.json());
+                setTasks(Array.isArray(taskBody) ? taskBody : []);
+            }
+            else {
+                setTasks([]);
+            }
+            if (tickerRes.ok) {
+                const tickerBody = (await tickerRes.json());
+                if (tickerBody.ticker)
+                    setAuxTicker(tickerBody.ticker);
+            }
+        }
+        catch (error) {
+            setLoadError(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            setLoadingBoard(false);
+        }
+    }, []);
+    useEffect(() => {
+        void refreshBoard();
+    }, [refreshBoard]);
+    const onToggleAuxTicker = useCallback(async (enabled) => {
+        setAuxTickerBusy(true);
+        try {
+            const res = await fetch("/api/operator/v1/night-aux-ticker", {
+                method: "POST",
+                credentials: "same-origin",
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-Loop-Console-Confirmation": confirmationToken(),
+                },
+                body: JSON.stringify({ enabled }),
+            });
+            const body = (await res.json());
+            if (!res.ok || body.ok === false || !body.ticker) {
+                setOpError(body.error?.message ??
+                    `切换前台辅助 ticker 失败（HTTP ${res.status}）`);
+                return;
+            }
+            setAuxTicker(body.ticker);
+        }
+        catch (error) {
+            setOpError(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            setAuxTickerBusy(false);
+        }
+    }, [setOpError]);
+    const onMorningReport = useCallback(async () => {
+        try {
+            const res = await fetch("/api/night-jobs/morning", {
+                credentials: "same-origin",
+            });
+            if (!res.ok) {
+                setOpError(`早晨报告加载失败（HTTP ${res.status}）`);
+                return;
+            }
+            const body = await res.json();
+            setMorningPreview(JSON.stringify(body, null, 2).slice(0, 4000));
+            setAdvancedOpen(true);
+        }
+        catch (error) {
+            setOpError(error instanceof Error ? error.message : String(error));
+        }
+    }, [setOpError]);
+    const doctorIssues = (doctor?.findings ?? []).filter((f) => f.severity === "error" || f.severity === "warning");
+    const clockHint = (doctor?.findings ?? []).find((f) => /clock/i.test(f.code) || /clock/i.test(f.message));
+    return {
+        list,
+        doctor,
+        tasks,
+        loadError,
+        loadingBoard,
+        advancedOpen,
+        setAdvancedOpen,
+        morningPreview,
+        auxTicker,
+        auxTickerBusy,
+        refreshBoard,
+        onToggleAuxTicker,
+        onMorningReport,
+        doctorIssues,
+        clockHint,
+    };
+}

package/dist/worker/console/static-src/night/useNightWizard.js

@@ -0,0 +1,171 @@
+import { useCallback, useMemo, useState } from "react";
+import { datetimeLocalToAdmissionAt, defaultNightAtLocal, extractNightPrepareReview, featureDirFromFeatureId, nightRowNeedsForceDiscard, } from "../night-prepare-result.js";
+import { requestId, } from "./night-types.js";
+/** Night scheduling wizard + row mutations: every write goes through
+ *  prepareMutationGate → Human Gate receipt → gated action. */
+export function useNightWizard(params) {
+    const { board, runAction, isActionSuccess, setOpError } = params;
+    const { tasks, refreshBoard } = board;
+    const [phase, setPhase] = useState("pick");
+    const [selectedKey, setSelectedKey] = useState("");
+    const [nightAt, setNightAt] = useState(defaultNightAtLocal);
+    const [taskCard, setTaskCard] = useState("");
+    const [review, setReview] = useState(null);
+    const [discardReason, setDiscardReason] = useState("");
+    const [discardTarget, setDiscardTarget] = useState(null);
+    const [forceDiscard, setForceDiscard] = useState(false);
+    const selectableTasks = useMemo(() => {
+        const rows = tasks.filter((t) => typeof t.featureId === "string" && t.featureId.trim() && t.taskId);
+        rows.sort((a, b) => {
+            const fa = a.featureId ?? "";
+            const fb = b.featureId ?? "";
+            if (fa !== fb)
+                return fa.localeCompare(fb);
+            return a.taskId.localeCompare(b.taskId);
+        });
+        return rows;
+    }, [tasks]);
+    const selectedTask = useMemo(() => {
+        if (!selectedKey)
+            return null;
+        return (selectableTasks.find((t) => `${t.featureId}::${t.taskId}` === selectedKey) ?? null);
+    }, [selectableTasks, selectedKey]);
+    const derivedFeatureDir = selectedTask?.featureId
+        ? featureDirFromFeatureId(selectedTask.featureId)
+        : "";
+    const runGatedMutation = useCallback(async (action, actionParams, clientPrefix) => {
+        const prep = await runAction("prepareMutationGate", {
+            action,
+            actionParams,
+        });
+        if (!isActionSuccess(prep))
+            return undefined;
+        const receiptSource = (prep?.result ?? prep);
+        const receipt = receiptSource.receiptId
+            ? receiptSource
+            : (receiptSource.result ?? receiptSource);
+        if (!receipt.receiptId || !receipt.humanGateToken) {
+            setOpError("prepareMutationGate 未返回可消费的 Human Gate receipt");
+            return undefined;
+        }
+        return runAction(action, {
+            ...actionParams,
+            confirmationId: receipt.receiptId,
+            humanGateToken: receipt.humanGateToken,
+        }, { clientRequestId: requestId(clientPrefix) });
+    }, [isActionSuccess, runAction, setOpError]);
+    const onPrepare = useCallback(async () => {
+        if (!selectedTask?.featureId) {
+            setOpError("请先点选 Feature / Task");
+            return;
+        }
+        const at = datetimeLocalToAdmissionAt(nightAt);
+        if (!at) {
+            setOpError("执行时间格式无效，请使用日期时间选择器");
+            return;
+        }
+        const actionParams = {
+            featureDir: featureDirFromFeatureId(selectedTask.featureId),
+            taskId: selectedTask.taskId,
+            at,
+            tz: "Asia/Shanghai",
+            ...(taskCard.trim() ? { taskCard: taskCard.trim() } : {}),
+        };
+        const body = await runGatedMutation("workerAdmissionPrepare", actionParams, "night-prepare");
+        if (!isActionSuccess(body))
+            return;
+        const packet = extractNightPrepareReview(body?.result ?? body);
+        if (!packet) {
+            setOpError("准备成功但未解析到 scheduleId / gateToken。请刷新后重试，或查看 Inspect。");
+            return;
+        }
+        setReview(packet);
+        setPhase("review");
+    }, [
+        isActionSuccess,
+        nightAt,
+        runGatedMutation,
+        selectedTask,
+        setOpError,
+        taskCard,
+    ]);
+    const onConfirmAdd = useCallback(async () => {
+        if (!review)
+            return;
+        const body = await runGatedMutation("workerSchedulerAdd", {
+            scheduleId: review.scheduleId,
+            approveGate: review.gateToken,
+        }, "night-add");
+        if (!isActionSuccess(body))
+            return;
+        setReview(null);
+        setPhase("pick");
+        setSelectedKey("");
+        setTaskCard("");
+        setNightAt(defaultNightAtLocal());
+        await refreshBoard();
+    }, [isActionSuccess, refreshBoard, review, runGatedMutation]);
+    const onCancelWizard = useCallback(() => {
+        setPhase("pick");
+        setReview(null);
+    }, []);
+    const onHarvest = useCallback(async (row) => {
+        const body = await runGatedMutation("workerSchedulerHarvest", { scheduleId: row.scheduleId }, "night-harvest");
+        if (!isActionSuccess(body))
+            return;
+        await refreshBoard();
+    }, [isActionSuccess, refreshBoard, runGatedMutation]);
+    const onDiscard = useCallback(async () => {
+        if (!discardTarget)
+            return;
+        const reason = discardReason.trim() || "discard from console night workbench";
+        const needsForce = nightRowNeedsForceDiscard(discardTarget.status);
+        const body = await runGatedMutation("workerSchedulerDiscard", {
+            scheduleId: discardTarget.scheduleId,
+            reason,
+            ...(needsForce || forceDiscard ? { force: true } : {}),
+        }, "night-discard");
+        if (!isActionSuccess(body))
+            return;
+        setDiscardTarget(null);
+        setDiscardReason("");
+        setForceDiscard(false);
+        await refreshBoard();
+    }, [
+        discardReason,
+        discardTarget,
+        forceDiscard,
+        isActionSuccess,
+        refreshBoard,
+        runGatedMutation,
+    ]);
+    const openDiscard = useCallback((row) => {
+        setDiscardTarget(row);
+        setForceDiscard(nightRowNeedsForceDiscard(row.status));
+        setDiscardReason("");
+    }, []);
+    return {
+        phase,
+        selectedKey,
+        setSelectedKey,
+        nightAt,
+        setNightAt,
+        taskCard,
+        setTaskCard,
+        review,
+        discardReason,
+        setDiscardReason,
+        discardTarget,
+        setDiscardTarget,
+        forceDiscard,
+        setForceDiscard,
+        selectableTasks,
+        derivedFeatureDir,
+        onPrepare,
+        onConfirmAdd,
+        onCancelWizard,
+        onHarvest,
+        onDiscard,
+        openDiscard,
+    };
+}