@tea-agent/loop-agent 0.42.0 → 0.42.1

package/dist/worker/console/static-src/operator-chat/pending-user-message.js

@@ -1,25 +1,35 @@
-/** Insert the optimistic user bubble and assistant slot exactly once. */
+/** Insert the optimistic user bubble and assistant slot exactly once.
+ *
+ * The optimistic user row is the ONLY row carrying `pending: true`. Every
+ * rollback path deletes pending rows by clientRequestId; a durable row that
+ * already replaced it must survive (2026-09-08). */
 export function appendPendingSubmission(messages, pending) {
     if (messages.some((message) => message.clientRequestId === pending.clientRequestId))
         return [...messages];
-    return [...messages, pending.user, pending.assistant];
+    return [...messages, { ...pending.user, pending: true }, pending.assistant];
 }
-/** Replace an optimistic user bubble with its durable server message in place. */
+/** Merge a durable user message into its optimistic or snapshot row in place.
+ *
+ * The replacement drops the `pending` marker: the row is server truth from now
+ * on, so a later adopt/rejected/connect rollback for the same clientRequestId
+ * must not delete it. Matching the durable id also dedupes retained SSE replay
+ * against a session snapshot whose stored row predates clientRequestId. */
 export function replacePendingUserMessage(messages, clientRequestId, durable) {
     let replaced = false;
-    const next = messages.filter((message) => {
-        if (message.clientRequestId !== clientRequestId)
-            return true;
+    const next = [];
+    for (const message of messages) {
+        const matches = message.clientRequestId === clientRequestId || message.id === durable.id;
+        if (!matches) {
+            next.push(message);
+            continue;
+        }
         if (replaced)
-            return false;
+            continue;
         replaced = true;
-        return true;
-    });
-    return replaced
-        ? next.map((message) => message.clientRequestId === clientRequestId
-            ? { ...message, ...durable, clientRequestId }
-            : message)
-        : [...next, durable];
+        const { pending: _pending, ...rest } = message;
+        next.push({ ...rest, ...durable, clientRequestId });
+    }
+    return replaced ? next : [...next, durable];
 }
 /** Keep an unconfirmed optimistic bubble when a recovery snapshot lacks it. */
 export function mergePendingSubmissionOnHydration(canonical, pending) {
@@ -27,6 +37,8 @@ export function mergePendingSubmissionOnHydration(canonical, pending) {
         return [...canonical];
     return appendPendingSubmission(canonical, pending);
 }
+/** Drop only the unconfirmed optimistic rows for a submission. A durable row
+ *  that already replaced the optimistic one is left untouched. */
 export function removePendingSubmission(messages, clientRequestId) {
-    return messages.filter((message) => message.clientRequestId !== clientRequestId);
+    return messages.filter((message) => message.clientRequestId !== clientRequestId || message.pending !== true);
 }

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

@@ -0,0 +1,41 @@
+import { isSubagentTool } from "../../chat/tool-preview.js";
+/**
+ * Count the collapsed-turn disclosure buckets exactly like DSH
+ * `TurnProcessNodeView`: tool calls, process messages and subagents, in that
+ * order. Built-in subagent delegations (`Agent` tool) count as subagents, not
+ * as ordinary tool calls (2026-09-08 alignment).
+ *
+ * @param items - ordered process nodes of one turn.
+ * @returns the three bucket counts.
+ */
+export function countTurnProcessItems(items) {
+    let toolCalls = 0;
+    let messages = 0;
+    let subagents = 0;
+    for (const item of items) {
+        if (item.kind === "tool") {
+            if (isSubagentTool(item.tool.toolName))
+                subagents += 1;
+            else
+                toolCalls += 1;
+            continue;
+        }
+        messages += 1;
+    }
+    return { toolCalls, messages, subagents };
+}
+/**
+ * Summary label for a completed turn's process disclosure.
+ *
+ * @param counts - bucket counts from {@link countTurnProcessItems}.
+ * @returns `N 次工具调用 · M 条消息 · K 个 subagent`, or「已思考」when empty.
+ */
+export function buildTurnProcessLabel(counts) {
+    return ([
+        counts.toolCalls > 0 ? `${counts.toolCalls} 次工具调用` : "",
+        counts.messages > 0 ? `${counts.messages} 条消息` : "",
+        counts.subagents > 0 ? `${counts.subagents} 个 subagent` : "",
+    ]
+        .filter(Boolean)
+        .join(" · ") || "已思考");
+}

package/dist/worker/console/static-src/operator-chat/turn-group-equality.js

@@ -0,0 +1,13 @@
+function sameReferences(previous, next) {
+    return (previous.length === next.length &&
+        previous.every((value, index) => value === next[index]));
+}
+/** A completed group's rendered projection is reusable only while every source
+ * object that feeds grouping and process-item derivation remains unchanged. */
+export function sameTurnGroupInputs(previous, next) {
+    return (previous.key === next.key &&
+        previous.user === next.user &&
+        previous.live === next.live &&
+        sameReferences(previous.assistants, next.assistants) &&
+        sameReferences(previous.tools, next.tools));
+}

package/dist/worker/console/static-src/operator-chat/use-searchable-hidden.js

@@ -0,0 +1,51 @@
+import { useEffect, useLayoutEffect, useRef } from "react";
+/** Whether this browser can reveal `hidden="until-found"` content through
+ *  `beforematch` (Chrome 102+, Firefox 148+, Safari: not supported at all).
+ *  `content-visibility` support does NOT imply this — Safari 18+ and
+ *  Firefox 125–147 have the former without the latter. */
+function supportsUntilFound() {
+    return typeof document !== "undefined" && "onbeforematch" in document.body;
+}
+/**
+ * Collapse content without removing it from the document: the element gets
+ * `hidden="until-found"` so browser find-in-page can still reach the text, and
+ * a match fires `beforematch`, which reveals (expands) the disclosure again.
+ *
+ * Mirrors DSH `useSearchableHidden` (2026-09-08 alignment). Browsers without
+ * `until-found` support get a plain `hidden=""` element, which keeps the
+ * pre-alignment behavior (collapsed and not searchable).
+ *
+ * @param hidden - whether the content is collapsed.
+ * @param reveal - expand callback invoked on `beforematch` and when the
+ *   collapsed subtree already owns focus.
+ * @returns ref for the collapsible container.
+ */
+export function useSearchableHidden(hidden, reveal) {
+    const ref = useRef(null);
+    useLayoutEffect(() => {
+        const element = ref.current;
+        if (element === null)
+            return;
+        // Focus would otherwise be lost inside a hidden subtree.
+        if (hidden && element.contains(element.ownerDocument.activeElement)) {
+            reveal();
+            return;
+        }
+        if (hidden) {
+            element.setAttribute("hidden", supportsUntilFound() ? "until-found" : "");
+        }
+        else {
+            element.removeAttribute("hidden");
+        }
+    }, [hidden, reveal]);
+    useEffect(() => {
+        const element = ref.current;
+        if (element === null)
+            return;
+        element.addEventListener("beforematch", reveal);
+        return () => {
+            element.removeEventListener("beforematch", reveal);
+        };
+    }, [reveal]);
+    return ref;
+}

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

@@ -2,6 +2,7 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { runtimeSelectionFromRecord } from "../../chat/runtime-selection.js";
 import { hydrateSessionThread } from "../../chat/turn-process.js";
 import { forgetActiveChatSession, readActiveChatSessionId, rememberActiveChatSession, } from "../../chat/workspace-landing.js";
+import { DEFAULT_CONSOLE_CHAT_SESSION_MODE } from "../../chat/session-mode-view.js";
 import { confirmationToken } from "./format.js";
 import { isLostChatSessionError } from "./runtime-snapshot-store.js";
 import { upsertCompactionMessage } from "./compaction-message.js";
@@ -67,6 +68,8 @@ function sameSessionSummary(a, b) {
         a.model?.modelId === b.model?.modelId &&
         a.thinkingLevel === b.thinkingLevel &&
         a.isBlank === b.isBlank &&
+        (a.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE) ===
+            (b.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE) &&
         a.optimisticState === b.optimisticState &&
         sameQueueSummary(a, b));
 }
@@ -83,8 +86,18 @@ export function stabilizeSessionList(previous, next) {
     });
     return changed ? stabilized : previous;
 }
+/** Project a session detail/list record into the active ChatSessionInfo. */
+export function projectActiveChatSession(session, fallbackWorkspaceId) {
+    const workspaceId = session.workspaceId?.trim() || fallbackWorkspaceId?.trim() || "";
+    return {
+        sessionId: session.sessionId,
+        ...(workspaceId ? { workspaceId } : {}),
+        sessionMode: session.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE,
+        ...runtimeSelectionFromRecord(session),
+    };
+}
 /** Select a server-confirmed blank session owned by the requested workspace. */
-export function findReusableBlankSession(list, workspaceId) {
+export function findReusableBlankSession(list, workspaceId, sessionMode = DEFAULT_CONSOLE_CHAT_SESSION_MODE) {
     const scope = workspaceId.trim();
     if (!scope)
         return undefined;
@@ -93,7 +106,8 @@ export function findReusableBlankSession(list, workspaceId) {
         item.isBlank === true &&
         item.turnPhase === "idle" &&
         !item.activeTurnId &&
-        !item.optimisticState);
+        !item.optimisticState &&
+        (item.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE) === sessionMode);
 }
 export async function createSessionAndPrimeTitleWatcher(input) {
     if (input.creatingRef?.current) {
@@ -127,7 +141,13 @@ export async function createSessionAndPrimeTitleWatcher(input) {
         const body = (await res.json());
         if (!body.session)
             throw new Error("创建会话响应缺少 durable session");
-        const durable = { ...body.session, isBlank: true };
+        const durable = {
+            ...body.session,
+            isBlank: true,
+            sessionMode: body.session.sessionMode ??
+                input.options?.sessionMode ??
+                DEFAULT_CONSOLE_CHAT_SESSION_MODE,
+        };
         const created = {
             sessionId: durable.sessionId,
             ...(durable.workspaceId || input.options?.workspaceId
@@ -135,6 +155,7 @@ export async function createSessionAndPrimeTitleWatcher(input) {
                     workspaceId: durable.workspaceId ?? input.options?.workspaceId,
                 }
                 : {}),
+            sessionMode: durable.sessionMode,
             ...runtimeSelectionFromRecord(durable),
         };
         const nextList = replaceOptimisticSession(input.sessionListRef.current, input.options?.optimisticSessionId, durable);
@@ -402,11 +423,7 @@ export function useChatSessions(params) {
             }
             if (selectionVersion !== sessionSelectionVersionRef.current)
                 return false;
-            const next = {
-                sessionId: body.session.sessionId,
-                ...(body.session.workspaceId ? { workspaceId: body.session.workspaceId } : {}),
-                ...runtimeSelectionFromRecord(body.session),
-            };
+            const next = projectActiveChatSession(body.session);
             // AC-002: session switch (same or cross workspace) never aborts other
             // sessions' background request controllers; the single /events owner is
             // re-bound by useChatStream's session effect.
@@ -538,15 +555,7 @@ export function useChatSessions(params) {
                     selectionVersion !== sessionSelectionVersionRef.current ||
                     !body.session)
                     return;
-                const restored = {
-                    sessionId: body.session.sessionId,
-                    ...(body.session.workspaceId
-                        ? { workspaceId: body.session.workspaceId }
-                        : workspaceId
-                            ? { workspaceId }
-                            : {}),
-                    ...runtimeSelectionFromRecord(body.session),
-                };
+                const restored = projectActiveChatSession(body.session, workspaceId);
                 refs.sessionGenerationRef.current += 1;
                 refs.sessionRef.current = restored;
                 // Do not seed Last-Event-ID here: session messages are restored
@@ -619,6 +628,7 @@ export function useChatSessions(params) {
             setError("创建会话需要选择一个有效的工作区（不会回退默认工作区）");
             return Promise.reject(new Error("WORKSPACE_REQUIRED"));
         }
+        const sessionMode = options?.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE;
         const optimisticSessionId = `optimistic-chat-${Date.now()}-${Math.random().toString(16).slice(2)}`;
         const now = new Date().toISOString();
         const optimisticRow = {
@@ -627,6 +637,7 @@ export function useChatSessions(params) {
             state: "active",
             updatedAt: now,
             turnPhase: "idle",
+            sessionMode,
             optimisticState: "creating",
         };
         pendingCreatedRowsRef.current.set(optimisticSessionId, optimisticRow);
@@ -669,9 +680,10 @@ export function useChatSessions(params) {
         }
         // A caller-provided snapshot is an explicit new-session boundary; reusing
         // an existing shell would silently drop that context suffix.
+        const sessionMode = options?.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE;
         const reusable = options?.snapshot
             ? undefined
-            : findReusableBlankSession(sessionListRef.current, scope);
+            : findReusableBlankSession(sessionListRef.current, scope, sessionMode);
         if (reusable) {
             if (previousSession?.sessionId === reusable.sessionId)
                 return previousSession;
@@ -681,6 +693,7 @@ export function useChatSessions(params) {
             return {
                 sessionId: reusable.sessionId,
                 ...(reusable.workspaceId ? { workspaceId: reusable.workspaceId } : {}),
+                sessionMode: reusable.sessionMode ?? sessionMode,
                 ...runtimeSelectionFromRecord(reusable),
             };
         }

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

@@ -53,7 +53,11 @@ function clearEmptyAssistant(setMessages, assistantId) {
         return;
     setMessages((messages) => messages.filter((message) => !(message.id === assistantId &&
         message.role === "assistant" &&
-        !message.text.trim())));
+        !message.text.trim() &&
+        // A row carrying only thinking/tool blocks is real content. Deleting
+        // it here dropped the turn's process nodes while the settled path in
+        // chat-sse-events deliberately keeps them (2026-09-08).
+        !(message.content && message.content.length > 0))));
 }
 /** One GET /events stream owns all Chat events. Sending a prompt creates a
  * detached Turn resource only; it never opens a second inline SSE consumer. */
@@ -140,7 +144,10 @@ export function useChatStream(params) {
                                 current.generation === generation)
                                 current.ready = true;
                             replay = false;
-                            continue;
+                            // Fall through: the applier owns the buffered-replay flush and
+                            // returns immediately for this event. `continue` here silently
+                            // dropped that flush, so a reconnect that landed after the
+                            // turn settled never restored the answer (2026-09-08).
                         }
                         const assistantId = refs.assistantIdRef.current ?? fallbackAssistantId;
                         const eventId = applySseBlock(block, assistantId, {
@@ -713,6 +720,15 @@ export function useChatStream(params) {
         if (refs.sessionRef.current?.sessionId !== activeSession.sessionId ||
             refs.sessionGenerationRef.current !== generation) {
             releaseSubmitOwnership(clientRequestId);
+            if (refs.sessionRef.current?.sessionId === activeSession.sessionId) {
+                // Same session, newer generation: the activation snapshot replaced
+                // the thread, so the optimistic row is gone. Restore the draft
+                // instead of losing the user's text silently (2026-09-08).
+                setMessages((messages) => removePendingSubmission(messages, clientRequestId));
+                clearEmptyAssistant(setMessages, assistantId);
+                setInput(draftText);
+                setPendingImages(draftImages);
+            }
             return;
         }
         // Attachments stay until accepted (AC/UIS-accepted).

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

@@ -1,10 +1,12 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from "react";
 import { buildTurnProcessGroups, hydrateSessionThread, selectRecentTurnGroups, } from "../../chat/turn-process.js";
+import { isToolFailure } from "../../chat/tool-preview.js";
 import { mergeOperationCardState, } from "../../chat/operation-card.js";
 import { createChatSseEventApplier, } from "./chat-sse-events.js";
 import { mergePendingSubmissionOnHydration } from "./pending-user-message.js";
 import { taskContextUnchanged } from "./format.js";
 import { upsertCompactionMessage } from "./compaction-message.js";
+import { sameTurnGroupInputs } from "./turn-group-equality.js";
 const EMPTY_USAGE = {
     inputTokens: 0,
     outputTokens: 0,
@@ -115,6 +117,12 @@ export function useChatThread(params) {
     // (UI-08); the SSE applier must not open the process panel.
     void params.setProcessOpen;
     const [messages, setMessages] = useState([]);
+    /** Rendered-messages mirror for the replay flush: it must resolve its target
+     *  row synchronously, before React commits the queued updater (2026-09-08). */
+    const messagesRef = useRef([]);
+    useLayoutEffect(() => {
+        messagesRef.current = messages;
+    }, [messages]);
     const [toolCalls, setToolCalls] = useState([]);
     const [operationCards, setOperationCards] = useState([]);
     const [artifactCards, setArtifactCards] = useState([]);
@@ -187,6 +195,7 @@ export function useChatThread(params) {
         onTelemetryRefresh: () => void refreshSessionTelemetry(),
         setMessages,
         setToolCalls,
+        getMessages: () => messagesRef.current,
     }), [refs, onReconcile, setError, refreshSessionTelemetry]);
     /** 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). */
@@ -285,7 +294,7 @@ export function useChatThread(params) {
         if (toolCalls.length === 0)
             return null;
         const running = toolCalls.filter((t) => t.status === "running");
-        const errored = toolCalls.filter((t) => t.status === "error");
+        const errored = toolCalls.filter((t) => isToolFailure(t));
         const current = running[running.length - 1];
         let statusLabel = "完成";
         let statusKind = "ok";
@@ -348,7 +357,9 @@ export function useChatThread(params) {
         const previous = new Map(completedGroupsRef.current.map((group) => [group.key, group]));
         const all = built.map((group) => {
             const cached = previous.get(group.key);
-            return cached && !group.live ? cached : group;
+            return cached && !group.live && sameTurnGroupInputs(cached, group)
+                ? cached
+                : group;
         });
         completedGroupsRef.current = all.filter((group) => !group.live);
         previousTimelineRef.current = {
@@ -450,7 +461,31 @@ export function useChatThread(params) {
     /** Adopt a freshly activated session's hydrated thread + streaming flags. */
     const applyActivatedSession = useCallback((next) => {
         const visuallyStopped = next.turnPhase === "stopping";
-        setMessages(next.messages);
+        // A submission still owned for THIS session keeps its optimistic bubble
+        // across an activation snapshot (refresh / reopen); a lease owned by
+        // another session must never leak into this thread (2026-09-08).
+        const ownedPending = refs.pendingSubmissionRef.current?.sessionId ===
+            refs.sessionRef.current?.sessionId
+            ? refs.pendingSubmissionRef.current
+            : undefined;
+        setMessages(mergePendingSubmissionOnHydration(next.messages, ownedPending
+            ? {
+                clientRequestId: ownedPending.clientRequestId,
+                user: {
+                    id: ownedPending.userMessageId,
+                    role: "user",
+                    text: ownedPending.text,
+                    createdAt: Date.now(),
+                    clientRequestId: ownedPending.clientRequestId,
+                },
+                assistant: {
+                    id: ownedPending.assistantId,
+                    role: "assistant",
+                    text: "",
+                    createdAt: Date.now(),
+                },
+            }
+            : undefined));
         setToolCalls(next.toolCalls);
         setOperationCards([]);
         setHumanGateCards([]);

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, onUnrecoverableSession } = params;
+    const { origin, sessionId, sessionMode, refs, setError, onUnrecoverableSession, } = params;
     const [input, setInputState] = useState("");
     const [fileOptions, setFileOptions] = useState([]);
     const [pendingImages, setPendingImages] = useState([]);
@@ -28,7 +28,10 @@ export function useComposer(params) {
     }, []);
     const [shortcutIndex, setShortcutIndex] = useState(0);
     const [dynamicCommands, setDynamicCommands] = useState([]);
-    const [commandCapabilities, setCommandCapabilities] = useState({ sddBingo: false });
+    const [commandCapabilities, setCommandCapabilities] = useState({
+        sddBingo: false,
+        sessionMode: undefined,
+    });
     const [dynamicCommandsLoading, setDynamicCommandsLoading] = useState(false);
     const [dynamicCommandsError, setDynamicCommandsError] = useState(null);
     const [commandsEpoch, setCommandsEpoch] = useState(0);
@@ -75,10 +78,10 @@ export function useComposer(params) {
         commandsSessionRef.current = sessionId;
         commandsGenerationRef.current += 1;
         setDynamicCommands([]);
-        setCommandCapabilities({ sddBingo: false });
+        setCommandCapabilities({ sddBingo: false, sessionMode });
         setDynamicCommandsError(null);
         setDynamicCommandsLoading(false);
-    }, [sessionId]);
+    }, [sessionId, sessionMode]);
     const loadDynamicCommands = useCallback(async () => {
         if (!sessionId) {
             setDynamicCommands([]);
@@ -124,7 +127,10 @@ export function useComposer(params) {
             if (!isCurrent())
                 return;
             setDynamicCommands(items);
-            setCommandCapabilities({ sddBingo: body?.capabilities?.sddBingo === true });
+            setCommandCapabilities({
+                sddBingo: body?.capabilities?.sddBingo === true,
+                sessionMode: body?.capabilities?.sessionMode ?? sessionMode,
+            });
             // 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);
@@ -134,14 +140,14 @@ export function useComposer(params) {
                 return;
             setDynamicCommandsError("动态命令加载失败");
             setDynamicCommands([]);
-            setCommandCapabilities({ sddBingo: false });
+            setCommandCapabilities({ sddBingo: false, sessionMode });
         }
         finally {
             if (isCurrent()) {
                 setDynamicCommandsLoading(false);
             }
         }
-    }, [origin, sessionId]);
+    }, [origin, sessionId, sessionMode]);
     // Lazy-load dynamic commands when slash palette opens or session changes.
     useEffect(() => {
         if (!sessionId)

package/dist/worker/console/static-src/operator-chat/user-turn-anchor-equality.js

@@ -0,0 +1,21 @@
+/** User anchors only depend on the ordered user-message objects, not on
+ * assistant/process updates that rebuild their containing turn groups. */
+export function sameUserMessages(previous, next) {
+    let previousIndex = 0;
+    let nextIndex = 0;
+    for (;;) {
+        while (previousIndex < previous.length && !previous[previousIndex].user) {
+            previousIndex += 1;
+        }
+        while (nextIndex < next.length && !next[nextIndex].user) {
+            nextIndex += 1;
+        }
+        if (previousIndex === previous.length || nextIndex === next.length) {
+            return previousIndex === previous.length && nextIndex === next.length;
+        }
+        if (previous[previousIndex].user !== next[nextIndex].user)
+            return false;
+        previousIndex += 1;
+        nextIndex += 1;
+    }
+}

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

@@ -37,6 +37,8 @@ import { UserQuestionRegistry } from "./chat/user-questions.js";
 import { TodoListRegistry } from "./chat/todos.js";
 import { GoalRegistry } from "./chat/goals.js";
 import { GoalRoundDriver } from "./chat/goal-round-driver.js";
+import { TerminalSessionRegistry } from "./chat/terminal-sessions.js";
+import { ScmService } from "./chat/scm-service.js";
 import { driveGoalRound, recoverDeferredTurns } from "./chat/routes.js";
 import { createOperationEventStore, } from "./operation-sse.js";
 import { OperationStore } from "../../infrastructure/console/operation-store.js";
@@ -254,7 +256,9 @@ export async function createWorkspaceContext(record, deps) {
             }
         },
     });
-    const sddDataAlignment = new SddDataAlignmentService(chatStore, new AimaxAuthReader(), deps.fetchImpl);
+    const aimaxAuth = new AimaxAuthReader();
+    await aimaxAuth.getToken();
+    const sddDataAlignment = new SddDataAlignmentService(chatStore, aimaxAuth, deps.fetchImpl);
     const chatEventEpoch = randomBytes(12).toString("hex");
     const chatEvents = createChatEventStore({
         appData,
@@ -285,6 +289,12 @@ export async function createWorkspaceContext(record, deps) {
         operations,
         operationEvents: events,
     });
+    // Persistent PTY terminal sessions shared by the model tool (terminal) and
+    // the Console UI terminal panel (HTTP API), keyed per chat session owner.
+    const terminalRegistry = new TerminalSessionRegistry();
+    // Workspace-scoped git source control shared by the model tool (scm) and
+    // the Console UI SCM panel (HTTP API).
+    const scmService = new ScmService(repoRoot);
     const chatRuntime = new ConsolePiRuntime({
         cwd: repoRoot,
         sessionDir: appData.chatSessions,
@@ -294,6 +304,8 @@ export async function createWorkspaceContext(record, deps) {
         todoRegistry,
         goalRegistry,
         sddDataAlignment,
+        terminalRegistry,
+        scmService,
     });
     let chatRouteDeps;
     const goalRoundDriver = new GoalRoundDriver((sessionId) => driveGoalRound(chatRouteDeps, sessionId));
@@ -308,6 +320,8 @@ export async function createWorkspaceContext(record, deps) {
         sddDataAlignment,
         goalRoundDriver,
         operationLinker: chatOperationLinker,
+        terminals: terminalRegistry,
+        scm: scmService,
         appData,
         bootToken: deps.bootToken,
         getConsoleOrigin: deps.getConsoleOrigin,