@tea-agent/loop-agent 0.1.0-fe-test.0

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

@@ -0,0 +1,280 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { buildTurnProcessGroups, hydrateSessionThread, selectRecentTurnGroups, } from "../../chat/turn-process.js";
+import { createChatSseEventApplier, } from "./chat-sse-events.js";
+import { taskContextUnchanged } from "./format.js";
+const EMPTY_USAGE = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    totalTokens: 0,
+};
+/**
+ * Thread state + SSE block parsing. The event-application logic itself lives
+ * in chat-sse-events.ts (createChatSseEventApplier); this hook owns the state
+ * slices it patches and the derived timeline projections.
+ */
+export function useChatThread(params) {
+    const { origin, refs, sessionId, setError, onReconcile } = params;
+    // setProcessOpen remains on the hook API for session lifecycle close/reset
+    // (UI-08); the SSE applier must not open the process panel.
+    void params.setProcessOpen;
+    const [messages, setMessages] = useState([]);
+    const [toolCalls, setToolCalls] = useState([]);
+    const [operationCards, setOperationCards] = useState([]);
+    const [artifactCards, setArtifactCards] = useState([]);
+    const [historyLimit, setHistoryLimit] = useState(50);
+    const [unread, setUnread] = useState(0);
+    const [humanGateCards, setHumanGateCards] = useState([]);
+    const [interview, setInterview] = useState(null);
+    const [taskContext, setTaskContext] = useState(null);
+    const [contextLoading, setContextLoading] = useState(false);
+    const [usage, setUsage] = useState(EMPTY_USAGE);
+    const [streaming, setStreaming] = useState(false);
+    /** Assistant bubble id for the in-flight turn; only this row shows the streaming cursor. */
+    const [streamingAssistantId, setStreamingAssistantId] = useState(null);
+    const [showSystemInMessages] = useState(false);
+    // All inputs are stable (state setters + the memoized refs bag), so the
+    // applier identity is stable across renders.
+    const applyChatSseEvent = useMemo(() => createChatSseEventApplier({
+        refs,
+        onReconcile,
+        setError,
+        setInterview,
+        setHumanGateCards,
+        setArtifactCards,
+        setStreaming,
+        setStreamingAssistantId,
+        setUnread,
+        setOperationCards,
+        setUsage,
+        setMessages,
+        setToolCalls,
+    }), [refs, onReconcile, setError]);
+    /** Parse + apply one raw SSE block (frames separated by \n\n). Returns the
+     *  eventId if the block carried an `id:` line (for Last-Event-ID tracking). */
+    const applySseBlock = useCallback((block, assistantId, options) => {
+        if ((options?.targetSessionId &&
+            refs.sessionRef.current?.sessionId !== options.targetSessionId) ||
+            (options?.generation !== undefined &&
+                refs.sessionGenerationRef.current !== options.generation))
+            return null;
+        const lines = block.split("\n");
+        let eventName = "message";
+        let dataStr = "";
+        let eventId = null;
+        for (const line of lines) {
+            if (line.startsWith("event: "))
+                eventName = line.slice(7).trim();
+            else if (line.startsWith("data: "))
+                dataStr += line.slice(6);
+            else if (line.startsWith("id: "))
+                eventId = line.slice(4).trim();
+        }
+        if (!dataStr)
+            return eventId;
+        let data;
+        try {
+            data = JSON.parse(dataStr);
+        }
+        catch {
+            return eventId;
+        }
+        const dedupeId = eventId ?? (typeof data.eventId === "string" ? data.eventId : null);
+        if (dedupeId) {
+            if (refs.seenEventIdsRef.current.has(dedupeId))
+                return dedupeId;
+            refs.seenEventIdsRef.current.add(dedupeId);
+        }
+        applyChatSseEvent(eventName, data, assistantId, options);
+        return eventId ?? dedupeId;
+    }, [applyChatSseEvent, refs]);
+    const loadTaskContext = useCallback(async (targetSessionId, options) => {
+        const background = options?.background === true;
+        if (!background)
+            setContextLoading(true);
+        try {
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(targetSessionId)}/context`, { credentials: "include" });
+            if (!res.ok)
+                return;
+            const body = (await res.json());
+            if (body.context &&
+                refs.sessionRef.current?.sessionId === targetSessionId) {
+                setTaskContext((prev) => taskContextUnchanged(prev, body.context) ? prev : body.context);
+            }
+        }
+        finally {
+            if (!background)
+                setContextLoading(false);
+        }
+    }, [origin, refs]);
+    useEffect(() => {
+        if (sessionId)
+            void loadTaskContext(sessionId);
+    }, [sessionId, loadTaskContext]);
+    useEffect(() => {
+        if (!sessionId)
+            return;
+        const timer = window.setTimeout(() => {
+            void loadTaskContext(sessionId, { background: true });
+        }, 350);
+        return () => window.clearTimeout(timer);
+    }, [sessionId, operationCards, humanGateCards, interview, loadTaskContext]);
+    const timelineMessages = useMemo(() => messages.filter((m) => m.role !== "system" || showSystemInMessages), [messages, showSystemInMessages]);
+    useEffect(() => {
+        const onVisibility = () => {
+            if (!document.hidden)
+                setUnread(0);
+        };
+        document.addEventListener("visibilitychange", onVisibility);
+        return () => document.removeEventListener("visibilitychange", onVisibility);
+    }, []);
+    const processSummary = useMemo(() => {
+        if (toolCalls.length === 0)
+            return null;
+        const running = toolCalls.filter((t) => t.status === "running");
+        const errored = toolCalls.filter((t) => t.status === "error");
+        const current = running[running.length - 1];
+        let statusLabel = "完成";
+        let statusKind = "ok";
+        if (errored.length > 0) {
+            statusLabel = `${errored.length} 次出错`;
+            statusKind = "error";
+        }
+        else if (running.length > 0) {
+            statusLabel = current ? `${current.toolName} 运行中` : "运行中";
+            statusKind = "running";
+        }
+        else {
+            // Completed is default/neutral; not shown as a permanent green success chip.
+            statusLabel = "";
+        }
+        return {
+            count: toolCalls.length,
+            statusLabel,
+            statusKind,
+        };
+    }, [toolCalls]);
+    const turnGroups = useMemo(() => {
+        const all = buildTurnProcessGroups({
+            messages: timelineMessages,
+            toolCalls,
+            streaming,
+            activeAssistantId: streamingAssistantId,
+        });
+        return selectRecentTurnGroups(all, historyLimit);
+    }, [
+        timelineMessages,
+        toolCalls,
+        streaming,
+        streamingAssistantId,
+        historyLimit,
+    ]);
+    const visibleMessages = useMemo(() => {
+        const next = [];
+        for (const group of turnGroups) {
+            if (group.user)
+                next.push(group.user);
+            next.push(...group.assistants);
+        }
+        return next;
+    }, [turnGroups]);
+    /** Reset all session-scoped projections before adopting a fresh session. */
+    const resetForNewSession = useCallback(() => {
+        setMessages([]);
+        setToolCalls([]);
+        setOperationCards([]);
+        setHumanGateCards([]);
+        setArtifactCards([]);
+        setInterview(null);
+        setTaskContext(null);
+        setUsage(EMPTY_USAGE);
+        setStreaming(false);
+        setStreamingAssistantId(null);
+        setUnread(0);
+        setHistoryLimit(50);
+        refs.usageResponseKeysRef.current = new Set();
+    }, [refs]);
+    /** Adopt a freshly activated session's hydrated thread + streaming flags. */
+    const applyActivatedSession = useCallback((next) => {
+        setMessages(next.messages);
+        setToolCalls(next.toolCalls);
+        setOperationCards([]);
+        setHumanGateCards([]);
+        setArtifactCards([]);
+        setTaskContext(null);
+        setInterview(null);
+        setUsage(EMPTY_USAGE);
+        refs.usageResponseKeysRef.current = new Set();
+        setStreaming(next.streaming);
+        setStreamingAssistantId(null);
+        setUnread(0);
+        setHistoryLimit(50);
+    }, [refs]);
+    /** Reconcile recovery (AC-001/AC-002/AC-003): reload the canonical session
+     *  facts (session-store messages + event-ring tail cursor) and REPLACE the
+     *  thread projection. Never calls applyActivatedSession: that would clear the
+     *  operation/human-gate/artifact/interview cards, which the reconnected tail
+     *  stream will not replay (they live in the ring, already consumed). */
+    const recoverSession = useCallback(async (targetSessionId) => {
+        try {
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(targetSessionId)}`, { credentials: "include" });
+            if (!res.ok)
+                return false;
+            const body = (await res.json());
+            if (!body.session ||
+                refs.sessionRef.current?.sessionId !== targetSessionId)
+                return false;
+            const activeTurnId = body.session.activeTurnId ?? null;
+            refs.activeTurnIdRef.current = activeTurnId;
+            refs.streamingRef.current = Boolean(activeTurnId);
+            // Resume the events stream from the snapshot tail so the next
+            // reconnect never immediately re-expires (AC-003). The refs below
+            // are reset so any follow-up tail replay re-applies cleanly.
+            refs.lastEventIdRef.current = body.lastEventId ?? null;
+            refs.seenEventIdsRef.current = new Set();
+            refs.turnAssistantIdsRef.current = new Map();
+            refs.sealedAssistantIdsRef.current = new Set();
+            const hydrated = hydrateSessionThread(body.session.messages ?? []);
+            setMessages(hydrated.messages);
+            setToolCalls(hydrated.toolCalls);
+            setStreamingAssistantId(null);
+            return true;
+        }
+        catch {
+            // Reload failed: keep the old cursor; the next stream reopen will
+            // trigger another reconcile and retry (best-effort recovery).
+            return false;
+        }
+    }, [origin, refs, setMessages, setToolCalls, setStreamingAssistantId]);
+    return {
+        messages,
+        setMessages,
+        toolCalls,
+        setToolCalls,
+        operationCards,
+        artifactCards,
+        historyLimit,
+        setHistoryLimit,
+        unread,
+        humanGateCards,
+        interview,
+        setInterview,
+        taskContext,
+        contextLoading,
+        usage,
+        streaming,
+        setStreaming,
+        streamingAssistantId,
+        setStreamingAssistantId,
+        visibleMessages,
+        turnGroups,
+        processSummary,
+        applyChatSseEvent,
+        applySseBlock,
+        loadTaskContext,
+        resetForNewSession,
+        applyActivatedSession,
+        recoverSession,
+    };
+}

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

@@ -0,0 +1,257 @@
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from "react";
+import { filterSlashCommands, mergeSlashCommands, } from "../../chat/shortcuts.js";
+import { confirmationToken } from "./format.js";
+import { clampShortcutIndex } from "./slash-palette-nav.js";
+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 [input, setInputState] = useState("");
+    const [fileOptions, setFileOptions] = useState([]);
+    const [pendingImages, setPendingImages] = useState([]);
+    const [shortcutOpen, setShortcutOpen] = useState(false);
+    /** Any composer text that starts with `/` should reveal the palette,
+     *  including draft restore. Escape can still close it without clearing. */
+    const setInput = useCallback((value) => {
+        if (typeof value === "function") {
+            setInputState((prev) => {
+                const next = value(prev);
+                setShortcutOpen(next.startsWith("/"));
+                return next;
+            });
+            return;
+        }
+        setInputState(value);
+        setShortcutOpen(value.startsWith("/"));
+    }, []);
+    const [shortcutIndex, setShortcutIndex] = useState(0);
+    const [dynamicCommands, setDynamicCommands] = useState([]);
+    const [dynamicCommandsLoading, setDynamicCommandsLoading] = useState(false);
+    const [dynamicCommandsError, setDynamicCommandsError] = useState(null);
+    const [commandsEpoch, setCommandsEpoch] = useState(0);
+    const textareaRef = useRef(null);
+    /** Active session generation for /commands; bumped immediately on switch (AC-2). */
+    const commandsSessionRef = useRef(sessionId);
+    const commandsGenerationRef = useRef(0);
+    const handleInputChange = useCallback((value) => {
+        setInput(value);
+        setShortcutOpen(value.startsWith("/"));
+        setShortcutIndex(0);
+    }, []);
+    // Immediate invalidation on A→B even when B palette never opens (AC-2).
+    useLayoutEffect(() => {
+        commandsSessionRef.current = sessionId;
+        commandsGenerationRef.current += 1;
+        setDynamicCommands([]);
+        setDynamicCommandsError(null);
+        setDynamicCommandsLoading(false);
+    }, [sessionId]);
+    const loadDynamicCommands = useCallback(async () => {
+        if (!sessionId) {
+            setDynamicCommands([]);
+            setDynamicCommandsError(null);
+            setDynamicCommandsLoading(false);
+            return;
+        }
+        const target = sessionId;
+        const generation = commandsGenerationRef.current;
+        commandsSessionRef.current = target;
+        setDynamicCommandsLoading(true);
+        setDynamicCommandsError(null);
+        const isCurrent = () => commandsSessionRef.current === target &&
+            commandsGenerationRef.current === generation;
+        try {
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(target)}/commands`, { credentials: "include" });
+            if (!isCurrent())
+                return;
+            if (!res.ok) {
+                setDynamicCommandsError("动态命令加载失败");
+                setDynamicCommands([]);
+                return;
+            }
+            const body = (await res.json().catch(() => null));
+            const items = [];
+            for (const raw of body?.commands ?? []) {
+                const source = raw.source;
+                if (source !== "extension" &&
+                    source !== "prompt" &&
+                    source !== "skill") {
+                    continue;
+                }
+                const command = String(raw.command ?? raw.name ?? "").trim();
+                if (!command)
+                    continue;
+                items.push({
+                    command: command.startsWith("/") ? command : `/${command}`,
+                    label: String(raw.label ?? raw.name ?? command),
+                    description: String(raw.description ?? ""),
+                    source,
+                });
+            }
+            if (!isCurrent())
+                return;
+            setDynamicCommands(items);
+            // 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);
+        }
+        catch {
+            if (!isCurrent())
+                return;
+            setDynamicCommandsError("动态命令加载失败");
+            setDynamicCommands([]);
+        }
+        finally {
+            if (isCurrent()) {
+                setDynamicCommandsLoading(false);
+            }
+        }
+    }, [origin, sessionId]);
+    // Lazy-load dynamic commands when slash palette opens or session changes.
+    useEffect(() => {
+        if (!sessionId)
+            return;
+        if (!shortcutOpen && commandsEpoch === 0)
+            return;
+        void loadDynamicCommands();
+    }, [sessionId, shortcutOpen, commandsEpoch, loadDynamicCommands]);
+    const retryDynamicCommands = useCallback(() => {
+        setCommandsEpoch((n) => n + 1);
+        void loadDynamicCommands();
+    }, [loadDynamicCommands]);
+    useEffect(() => {
+        if (!sessionId)
+            return;
+        const match = input
+            .slice(0, textareaRef.current?.selectionStart ?? input.length)
+            .match(/(?:^|\s)@([^\s@]*)$/);
+        if (!match) {
+            setFileOptions([]);
+            return;
+        }
+        const timer = window.setTimeout(() => {
+            void fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/files?q=${encodeURIComponent(match[1] ?? "")}`)
+                .then((r) => (r.ok ? r.json() : null))
+                .then((body) => setFileOptions((body?.files ?? []).map((item) => item.path)));
+        }, 150);
+        return () => window.clearTimeout(timer);
+    }, [origin, sessionId, input]);
+    const insertFileReference = useCallback((file) => {
+        const caret = textareaRef.current?.selectionStart ?? input.length;
+        const before = input.slice(0, caret);
+        const start = before.search(/@[^\s@]*$/);
+        if (start < 0)
+            return;
+        setInput(`${input.slice(0, start)}@${file} ${input.slice(caret)}`);
+        setFileOptions([]);
+    }, [input]);
+    const addImagesFromFiles = useCallback((files) => {
+        for (const file of Array.from(files).slice(0, 4)) {
+            if (!file.type.startsWith("image/") || file.size > 5 * 1024 * 1024) {
+                setError("图片仅支持 PNG/JPEG/GIF/WebP，单张不超过 5 MiB");
+                continue;
+            }
+            const reader = new FileReader();
+            reader.onload = () => {
+                const value = String(reader.result ?? "");
+                const data = value.slice(value.indexOf(",") + 1);
+                setPendingImages((items) => [
+                    ...items,
+                    {
+                        name: file.name,
+                        type: "image",
+                        mimeType: file.type,
+                        data,
+                    },
+                ].slice(0, 4));
+            };
+            reader.readAsDataURL(file);
+        }
+    }, [setError]);
+    const removeImage = useCallback((image) => {
+        setPendingImages((items) => items.filter((item) => item !== image));
+    }, []);
+    // Auto-grow textarea height.
+    useLayoutEffect(() => {
+        const ta = textareaRef.current;
+        if (!ta)
+            return;
+        ta.style.height = "auto";
+        ta.style.height = `${Math.min(ta.scrollHeight, 280)}px`;
+    }, [input]);
+    // Debounced server-side composer draft sync.
+    useEffect(() => {
+        if (!sessionId)
+            return;
+        const timer = window.setTimeout(() => {
+            void fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/draft`, {
+                method: "PUT",
+                credentials: "include",
+                headers: {
+                    "content-type": "application/json",
+                    "x-loop-console-confirmation": confirmationToken(),
+                },
+                body: JSON.stringify({ text: input }),
+            });
+        }, 400);
+        return () => window.clearTimeout(timer);
+    }, [origin, sessionId, input]);
+    const mergedCommands = useMemo(() => mergeSlashCommands(dynamicCommands), [dynamicCommands]);
+    const filteredShortcuts = useMemo(() => input.startsWith("/")
+        ? filterSlashCommands(mergedCommands, input)
+        : [], [input, mergedCommands]);
+    // Keep the active option index inside the current candidate range (UI-12
+    // AC-011): dynamic loads completing/failing empty, retries, session
+    // switches, late responses and search shrink all funnel through
+    // filteredShortcuts.length. The clamped index always matches a rendered
+    // `oc-shortcut-option-${globalIndex}` id (same source of truth).
+    useEffect(() => {
+        setShortcutIndex((index) => clampShortcutIndex(index, filteredShortcuts.length));
+    }, [filteredShortcuts.length]);
+    const onCompositionStart = useCallback(() => {
+        refs.isComposingRef.current = true;
+    }, [refs]);
+    const onCompositionEnd = useCallback(() => {
+        refs.isComposingRef.current = false;
+        refs.compositionEndedAtRef.current = Date.now();
+    }, [refs]);
+    /** IME guard used by the ChatComposer keyboard wrapper (mirrors OperatorChat). */
+    const isComposingNow = useCallback(() => {
+        return refs.isComposingRef.current;
+    }, [refs]);
+    /** 100ms post-composition window (mirrors OperatorChat). */
+    const recentlyComposedNow = useCallback(() => {
+        return Date.now() - refs.compositionEndedAtRef.current < 100;
+    }, [refs]);
+    // Bind the shared runtime snapshot to the active session (the composer owns
+    // 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]);
+    return {
+        input,
+        setInput,
+        handleInputChange,
+        fileOptions,
+        pendingImages,
+        setPendingImages,
+        addImagesFromFiles,
+        removeImage,
+        shortcutOpen,
+        setShortcutOpen,
+        shortcutIndex,
+        setShortcutIndex,
+        filteredShortcuts,
+        dynamicCommandsLoading,
+        dynamicCommandsError,
+        retryDynamicCommands,
+        insertFileReference,
+        textareaRef,
+        onCompositionStart,
+        onCompositionEnd,
+        isComposingNow,
+        recentlyComposedNow,
+    };
+}

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

@@ -0,0 +1,108 @@
+import { useCallback, useState } from "react";
+import { confirmationToken } from "./format.js";
+/** Requirement Interview actions (grill-me flow) driven from the chat surface. */
+export function useInterview(params) {
+    const { origin, refs, thread, setError } = params;
+    const { interview, setInterview } = thread;
+    const [interviewAnswer, setInterviewAnswer] = useState("");
+    const startInterview = useCallback(async () => {
+        const active = refs.sessionRef.current;
+        if (!active)
+            return;
+        const taskId = window.prompt("Task ID（例如 2026-07-26-my-task）")?.trim();
+        if (!taskId)
+            return;
+        const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${active.sessionId}/interviews`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-loop-console-confirmation": confirmationToken(),
+            },
+            credentials: "include",
+            body: JSON.stringify({ taskId }),
+        });
+        const body = (await res.json());
+        if (!res.ok) {
+            setError(body.error?.message ?? `HTTP ${res.status}`);
+            return;
+        }
+        setInterview({
+            interviewSessionId: body.interview?.sessionId,
+            taskId,
+            state: body.interview?.state,
+            question: body.question,
+            draft: body.draft?.draft,
+            draftSha256: body.draft?.draftSha256,
+            assessment: body.assessment,
+        });
+    }, [origin, refs, setInterview, setError]);
+    const answerInterview = useCallback(async (response) => {
+        const active = refs.sessionRef.current;
+        if (!active || !interview?.interviewSessionId || !interview.question)
+            return;
+        const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${active.sessionId}/interviews/${interview.interviewSessionId}/answers`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-loop-console-confirmation": confirmationToken(),
+            },
+            credentials: "include",
+            body: JSON.stringify({
+                questionId: interview.question.id,
+                response,
+                ...(response === "override" ? { text: interviewAnswer } : {}),
+            }),
+        });
+        const body = (await res.json());
+        if (!res.ok) {
+            setError(body.error?.message ?? `HTTP ${res.status}`);
+            return;
+        }
+        setInterview((current) => ({
+            ...(current ?? {}),
+            state: body.interview?.state,
+            question: body.question,
+            draft: body.draft?.draft,
+            draftSha256: body.draft?.draftSha256,
+            assessment: body.assessment,
+            taskKindRecommendation: body.taskKindRecommendation ?? current?.taskKindRecommendation,
+        }));
+        setInterviewAnswer("");
+    }, [origin, refs, interview, interviewAnswer, setInterview, setError]);
+    const confirmTaskKind = useCallback(async () => {
+        const active = refs.sessionRef.current;
+        if (!active ||
+            !interview?.interviewSessionId ||
+            !interview.taskKindRecommendation)
+            return;
+        const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${active.sessionId}/interviews/${interview.interviewSessionId}/task-kind/confirm`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-loop-console-confirmation": confirmationToken(),
+            },
+            credentials: "include",
+            body: JSON.stringify({ taskKind: interview.taskKindRecommendation }),
+        });
+        const body = (await res.json());
+        if (!res.ok) {
+            setError(body.error?.message ?? `HTTP ${res.status}`);
+            return;
+        }
+        setInterview((current) => ({
+            ...(current ?? {}),
+            confirmedTaskKind: current?.taskKindRecommendation,
+            taskKindRecommendation: undefined,
+            draft: body.draft?.draft,
+            draftSha256: body.draft?.draftSha256,
+            assessment: body.assessment,
+        }));
+    }, [origin, refs, interview, setInterview, setError]);
+    return {
+        interviewAnswer,
+        setInterviewAnswer,
+        startInterview,
+        answerInterview,
+        confirmTaskKind,
+    };
+}