@tea-agent/loop-agent 0.42.0-next.9 → 0.42.1

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

@@ -1,9 +1,12 @@
-import { useCallback, useEffect, useMemo, 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,
@@ -114,10 +117,20 @@ 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([]);
     const [historyLimit, setHistoryLimit] = useState(50);
+    const [historyHasMore, setHistoryHasMore] = useState(false);
+    const [historyNextCursor, setHistoryNextCursor] = useState(null);
+    const [historyLoading, setHistoryLoading] = useState(false);
+    const historyLoadingRef = useRef(false);
     const [unread, setUnread] = useState(0);
     const [humanGateCards, setHumanGateCards] = useState([]);
     const [interview, setInterview] = useState(null);
@@ -136,6 +149,8 @@ export function useChatThread(params) {
     /** Assistant bubble id for the in-flight turn; only this row shows the streaming cursor. */
     const [streamingAssistantId, setStreamingAssistantId] = useState(null);
     const [showSystemInMessages] = useState(false);
+    const completedGroupsRef = useRef([]);
+    const previousTimelineRef = useRef(null);
     const refreshSessionTelemetry = useCallback(async () => {
         const targetSessionId = refs.sessionRef.current?.sessionId;
         if (!targetSessionId)
@@ -180,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). */
@@ -278,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";
@@ -301,12 +317,57 @@ export function useChatThread(params) {
         };
     }, [toolCalls]);
     const turnGroups = useMemo(() => {
-        const all = buildTurnProcessGroups({
+        const previousTimeline = previousTimelineRef.current;
+        let built;
+        const activeIndex = streamingAssistantId
+            ? timelineMessages.findIndex((message) => message.id === streamingAssistantId)
+            : -1;
+        const canBuildActiveTail = Boolean(previousTimeline && streaming && streamingAssistantId && activeIndex >= 0) &&
+            previousTimeline?.activeAssistantId === streamingAssistantId &&
+            (previousTimeline?.messages.every((message, index) => message.id === streamingAssistantId || timelineMessages[index]?.id === message.id) ?? false);
+        if (canBuildActiveTail && previousTimeline) {
+            let tailStart = activeIndex;
+            while (tailStart > 0 && timelineMessages[tailStart - 1]?.role !== "user")
+                tailStart -= 1;
+            const tailMessages = timelineMessages.slice(tailStart);
+            const tailIds = new Set(tailMessages.map((message) => message.id));
+            const tailTurnIds = new Set(tailMessages.map((message) => message.turnId).filter(Boolean));
+            const tailTools = toolCalls.filter((tool) => tailIds.has(tool.assistantMessageId ?? "") ||
+                (Boolean(tool.turnId) && tailTurnIds.has(tool.turnId)) ||
+                (tool.createdAt >= (tailMessages[0]?.createdAt ?? Number.POSITIVE_INFINITY)));
+            const activeTail = buildTurnProcessGroups({
+                messages: tailMessages,
+                toolCalls: tailTools,
+                streaming,
+                activeAssistantId: streamingAssistantId,
+            });
+            built = [...previousTimeline.groups.filter((group) => !group.live), ...activeTail];
+        }
+        else {
+            built = buildTurnProcessGroups({
+                messages: timelineMessages,
+                toolCalls,
+                streaming,
+                activeAssistantId: streamingAssistantId,
+            });
+        }
+        // Preserve completed group objects across streaming tokens. The active
+        // tail is rebuilt, while stable historical groups keep their references so
+        // memoized rows do not re-render or re-parse the full conversation.
+        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 && sameTurnGroupInputs(cached, group)
+                ? cached
+                : group;
+        });
+        completedGroupsRef.current = all.filter((group) => !group.live);
+        previousTimelineRef.current = {
             messages: timelineMessages,
             toolCalls,
-            streaming,
             activeAssistantId: streamingAssistantId,
-        });
+            groups: all,
+        };
         return selectRecentTurnGroups(all, historyLimit);
     }, [
         timelineMessages,
@@ -315,6 +376,50 @@ export function useChatThread(params) {
         streamingAssistantId,
         historyLimit,
     ]);
+    const loadEarlierMessages = useCallback(async () => {
+        const targetSessionId = refs.sessionRef.current?.sessionId;
+        const beforeId = historyNextCursor;
+        if (!targetSessionId || !historyHasMore || !beforeId || historyLoadingRef.current)
+            return false;
+        historyLoadingRef.current = true;
+        setHistoryLoading(true);
+        try {
+            const query = new URLSearchParams({ limit: "50", beforeId });
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(targetSessionId)}/messages?${query.toString()}`, { credentials: "include" });
+            if (!res.ok || refs.sessionRef.current?.sessionId !== targetSessionId)
+                return false;
+            const body = (await res.json());
+            const page = hydrateSessionThread(body.messages ?? []);
+            setMessages((current) => {
+                const seen = new Set();
+                const merged = [...page.messages, ...current].filter((message) => {
+                    if (seen.has(message.id))
+                        return false;
+                    seen.add(message.id);
+                    return true;
+                });
+                return merged.sort((a, b) => {
+                    if (a.eventSeq !== undefined && b.eventSeq !== undefined && a.eventSeq !== b.eventSeq)
+                        return a.eventSeq - b.eventSeq;
+                    return a.createdAt - b.createdAt;
+                });
+            });
+            setToolCalls((current) => {
+                const byId = new Map(current.map((tool) => [tool.id, tool]));
+                for (const tool of page.toolCalls)
+                    byId.set(tool.id, tool);
+                return [...byId.values()].sort((a, b) => a.createdAt - b.createdAt);
+            });
+            setHistoryHasMore(body.hasMore === true);
+            setHistoryNextCursor(body.nextCursor ?? null);
+            setHistoryLimit((value) => value + 50);
+            return true;
+        }
+        finally {
+            historyLoadingRef.current = false;
+            setHistoryLoading(false);
+        }
+    }, [historyHasMore, historyNextCursor, origin, refs]);
     const visibleMessages = useMemo(() => {
         const next = [];
         for (const group of turnGroups) {
@@ -346,12 +451,41 @@ export function useChatThread(params) {
         setStreamingAssistantId(null);
         setUnread(0);
         setHistoryLimit(50);
+        setHistoryHasMore(false);
+        setHistoryNextCursor(null);
+        historyLoadingRef.current = false;
+        completedGroupsRef.current = [];
+        previousTimelineRef.current = null;
         refs.usageResponseKeysRef.current = new Set();
     }, [refs]);
     /** 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([]);
@@ -374,6 +508,10 @@ export function useChatThread(params) {
         setStreamingAssistantId(null);
         setUnread(0);
         setHistoryLimit(50);
+        setHistoryHasMore(next.history?.hasMore === true);
+        setHistoryNextCursor(next.history?.nextCursor ?? null);
+        completedGroupsRef.current = [];
+        previousTimelineRef.current = null;
     }, [refs]);
     /** Reconcile recovery (AC-001/AC-002/AC-003): reload the canonical session
      *  facts (session-store messages + event-ring tail cursor) and REPLACE the
@@ -415,8 +553,29 @@ export function useChatThread(params) {
             refs.turnAssistantIdsRef.current = new Map();
             refs.sealedAssistantIdsRef.current = new Set();
             const hydrated = hydrateSessionThread(body.session.messages ?? []);
-            setMessages(mergeCompactionMessages(hydrated.messages, body.compactions));
+            const pending = refs.pendingSubmissionRef.current;
+            const recovered = mergePendingSubmissionOnHydration(hydrated.messages, pending
+                ? {
+                    clientRequestId: pending.clientRequestId,
+                    user: {
+                        id: pending.userMessageId,
+                        role: "user",
+                        text: pending.text,
+                        createdAt: Date.now(),
+                        clientRequestId: pending.clientRequestId,
+                    },
+                    assistant: {
+                        id: pending.assistantId,
+                        role: "assistant",
+                        text: "",
+                        createdAt: Date.now(),
+                    },
+                }
+                : undefined);
+            setMessages(mergeCompactionMessages(recovered, body.compactions));
             setToolCalls(hydrated.toolCalls);
+            setHistoryHasMore(body.history?.hasMore === true);
+            setHistoryNextCursor(body.history?.nextCursor ?? null);
             setStreamingAssistantId(null);
             return true;
         }
@@ -446,6 +605,10 @@ export function useChatThread(params) {
         artifactCards,
         historyLimit,
         setHistoryLimit,
+        historyHasMore,
+        historyNextCursor,
+        historyLoading,
+        loadEarlierMessages,
         unread,
         humanGateCards,
         interview,

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/static-src/shell/workspace-route.js

@@ -170,6 +170,10 @@ export function withWorkspaceId(href, workspaceId) {
     const qs = query.toString();
     return `/#${path}${qs ? `?${qs}` : ""}`;
 }
+/** The primary Observe mode is a section entry, not an object deep link. */
+export function buildPrimaryInspectHref(workspaceId) {
+    return withWorkspaceId(DEFAULT_INSPECT_HREF, workspaceId);
+}
 /** 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

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,

package/dist/worker/observe/node-transparency.js

@@ -1,8 +1,9 @@
+import { readFileBoundarySafe } from "../../shared/path-safety.js";
 import { createHash } from "node:crypto";
-import { lstat, readFile, realpath } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
-import { effectiveNodeContextV1Schema, } from "../../shared/context-transfer.js";
+import { redactSecrets, truncateUtf8Preview, redactSensitivePathsWithFindings } from "../../shared/preview.js";
+import { effectiveNodeContextV1Schema, computeContextDigest, } from "../../shared/context-transfer.js";
 import { buildArtifactBindingGraph, } from "../../workflows/dag/artifact-bindings.js";
 import { dagSpecSchema } from "../../workflows/dag/types.js";
 import { isSafeObservabilityIdentifier } from "../observability/event-store.js";
@@ -133,8 +134,7 @@ export async function loadDagNodeContextSummary(repoRoot, dagRunId, nodeId, atte
         };
     }
     else {
-        const rawReceipt = await readJsonObject(receiptResolved.result.absolutePath);
-        const parsedReceipt = effectiveNodeContextV1Schema.safeParse(rawReceipt);
+        const parsedReceipt = await readValidatedContextReceipt(loaded.facts.runDir, receiptResolved.result.absolutePath);
         if (!parsedReceipt.success ||
             parsedReceipt.data.identity.runId !== dagRunId ||
             parsedReceipt.data.identity.nodeId !== nodeId ||
@@ -160,6 +160,14 @@ export async function loadDagNodeContextSummary(repoRoot, dagRunId, nodeId, atte
                 contextDigest: receipt.contextDigest,
                 capturedAt: receipt.identity.capturedAt,
                 componentCount: receipt.orderedComponents.length,
+                components: receipt.orderedComponents.map((component) => ({
+                    index: component.index, kind: component.kind,
+                    logicalName: redactSensitivePathsWithFindings(redactSecrets(component.logicalName)).redacted,
+                    sourceIdentity: redactSensitivePathsWithFindings(redactSecrets(component.source.identity)).redacted,
+                    inclusion: component.inclusion, bytes: component.bytes, mediaType: component.mediaType,
+                    previewAvailable: Boolean(component.materializedPath && !["reference-only", "omitted"].includes(component.inclusion)),
+                    ...(component.omissionReason ? { omissionReason: redactSecrets(component.omissionReason) } : {}),
+                })),
                 componentKinds,
                 inclusionCounts,
                 truncationCount: receipt.promptAssembly.truncations.length,
@@ -353,11 +361,7 @@ function isTextPreviewMediaType(mediaType) {
         "application/sql",
     ].includes(normalized) || normalized.endsWith("+json") || normalized.endsWith("+xml");
 }
-function isInsideDirectory(root, candidate) {
-    const normalizedRoot = root.endsWith(path.sep) ? root : `${root}${path.sep}`;
-    return candidate.startsWith(normalizedRoot);
-}
-export async function loadDagNodeArtifactPreview(repoRoot, dagRunId, nodeId, artifactId) {
+async function loadVerifiedArtifactBytes(repoRoot, dagRunId, nodeId, artifactId) {
     if (!isSafeObservabilityIdentifier(nodeId) || !isSafeObservabilityIdentifier(artifactId)) {
         return {
             status: 400,
@@ -410,21 +414,7 @@ export async function loadDagNodeArtifactPreview(repoRoot, dagRunId, nodeId, art
     if (!resolved.ok)
         return failureForResolution(resolved.reason);
     try {
-        const [runRoot, artifactRealPath, fileStat] = await Promise.all([
-            realpath(resolved.result.runDir),
-            realpath(resolved.result.absolutePath),
-            lstat(resolved.result.absolutePath),
-        ]);
-        if (!isInsideDirectory(runRoot, artifactRealPath) ||
-            !fileStat.isFile() ||
-            fileStat.isSymbolicLink() ||
-            fileStat.nlink !== 1) {
-            return {
-                status: 422,
-                body: { error: "Artifact is not a safe regular file", reason: "unsafe-path" },
-            };
-        }
-        const bytes = await readFile(artifactRealPath);
+        const bytes = await readFileBoundarySafe({ boundaryRoot: resolved.result.runDir, targetPath: resolved.result.absolutePath, label: "recorded artifact" });
         const actualSha256 = createHash("sha256").update(bytes).digest("hex");
         if (actualSha256 !== fact.sha256 ||
             (typeof fact.bytes === "number" && fact.bytes !== bytes.byteLength)) {
@@ -436,57 +426,76 @@ export async function loadDagNodeArtifactPreview(repoRoot, dagRunId, nodeId, art
                 },
             };
         }
-        if (!isTextPreviewMediaType(artifact.mediaType)) {
-            return {
-                status: 200,
-                body: {
-                    schemaVersion: NODE_TRANSPARENCY_SCHEMA_VERSION,
-                    dagRunId,
-                    nodeId,
-                    producerNodeId: artifact.producerNodeId,
-                    artifactId,
-                    path: artifact.path,
-                    mediaType: artifact.mediaType,
-                    kind: artifact.kind,
-                    sha256: actualSha256,
-                    sourceBytes: bytes.byteLength,
-                    maxBytes: DAG_ARTIFACT_PREVIEW_MAX_BYTES,
-                    previewKind: "unsupported",
-                    content: null,
-                    truncated: false,
-                    redacted: false,
-                },
-            };
-        }
-        const raw = bytes.toString("utf8");
-        const redacted = redactSecrets(raw);
-        const content = truncateUtf8Preview(redacted, DAG_ARTIFACT_PREVIEW_MAX_BYTES);
+        return { status: 200, artifact, bytes, sha256: actualSha256 };
+    }
+    catch (error) {
         return {
-            status: 200,
-            body: {
-                schemaVersion: NODE_TRANSPARENCY_SCHEMA_VERSION,
-                dagRunId,
-                nodeId,
-                producerNodeId: artifact.producerNodeId,
-                artifactId,
-                path: artifact.path,
-                mediaType: artifact.mediaType,
-                kind: artifact.kind,
-                sha256: actualSha256,
-                sourceBytes: bytes.byteLength,
-                maxBytes: DAG_ARTIFACT_PREVIEW_MAX_BYTES,
-                previewKind: "text",
-                content,
-                truncated: content !== redacted,
-                redacted: redacted !== raw,
-            },
+            status: error.code === "ENOENT" ? 404 : 422,
+            body: { error: "Artifact file is unavailable or unsafe", reason: error.code === "ENOENT" ? "not-found" : "unsafe-path" },
         };
     }
+}
+export async function loadDagNodeArtifactPreview(repoRoot, dagRunId, nodeId, artifactId) {
+    const verified = await loadVerifiedArtifactBytes(repoRoot, dagRunId, nodeId, artifactId);
+    if (verified.status !== 200)
+        return verified;
+    const { artifact, bytes, sha256 } = verified;
+    const supported = isTextPreviewMediaType(artifact.mediaType);
+    const raw = supported ? bytes.toString("utf8") : "";
+    const safe = redactSecrets(raw);
+    const content = supported ? truncateUtf8Preview(safe, DAG_ARTIFACT_PREVIEW_MAX_BYTES) : null;
+    return { status: 200, body: { schemaVersion: 1, dagRunId, nodeId, producerNodeId: artifact.producerNodeId, artifactId, path: artifact.path, mediaType: artifact.mediaType, kind: artifact.kind, sha256, sourceBytes: bytes.byteLength, maxBytes: DAG_ARTIFACT_PREVIEW_MAX_BYTES, previewKind: supported ? "text" : "unsupported", content, truncated: supported && content !== safe, redacted: safe !== raw } };
+}
+/** Full text uses the same binding and safety checks as the bounded preview. */
+export async function loadDagNodeArtifactDownload(repoRoot, dagRunId, nodeId, artifactId) {
+    const verified = await loadVerifiedArtifactBytes(repoRoot, dagRunId, nodeId, artifactId);
+    if (verified.status !== 200)
+        return verified;
+    if (!isTextPreviewMediaType(verified.artifact.mediaType))
+        return { status: 422, body: { error: "Only text artifacts support redacted download", reason: "unsupported-media" } };
+    return { status: 200, download: { filename: `${artifactId}.redacted.txt`, bytes: Buffer.from(redactSecrets(verified.bytes.toString("utf8")), "utf8") } };
+}
+async function readValidatedContextReceipt(boundaryRoot, targetPath) {
+    try {
+        const bytes = await readFileBoundarySafe({ boundaryRoot, targetPath, label: "recorded context receipt" });
+        const parsed = effectiveNodeContextV1Schema.safeParse(JSON.parse(bytes.toString("utf8")));
+        if (parsed.success) {
+            const { contextDigest, ...context } = parsed.data;
+            if (computeContextDigest(context) === contextDigest)
+                return parsed;
+        }
+    }
+    catch { /* Missing, changed and unsafe receipts are unavailable. */ }
+    return effectiveNodeContextV1Schema.safeParse(null);
+}
+export async function loadDagNodeContextComponent(repoRoot, dagRunId, nodeId, attempt, componentIndex) {
+    if (!isSafeObservabilityIdentifier(nodeId) || !Number.isSafeInteger(attempt) || attempt < 1 || !Number.isSafeInteger(componentIndex) || componentIndex < 0)
+        return { status: 400, body: { error: "Invalid context selection", reason: "invalid-id" } };
+    const loaded = await loadRunFacts(repoRoot, dagRunId);
+    if (!loaded.ok)
+        return loaded.failure;
+    if (!loaded.facts.spec.tasks.some((task) => task.id === nodeId))
+        return { status: 404, body: { error: "DAG node not found", reason: "not-found" } };
+    const resolved = resolveDagRunArtifact(repoRoot, dagRunId, [nodeId, "context-receipts", `attempt-${attempt}.json`]);
+    if (!resolved.ok)
+        return failureForResolution(resolved.reason);
+    try {
+        const parsed = await readValidatedContextReceipt(loaded.facts.runDir, resolved.result.absolutePath);
+        if (!parsed.success || parsed.data.identity.runId !== dagRunId || parsed.data.identity.nodeId !== nodeId || parsed.data.identity.attempt !== attempt)
+            return { status: 422, body: { error: "Invalid recorded context", reason: "CONTEXT_COMPONENT_UNAVAILABLE" } };
+        const component = parsed.data.orderedComponents.find((entry) => entry.index === componentIndex);
+        if (!component?.materializedPath || ["reference-only", "omitted"].includes(component.inclusion))
+            return { status: 404, body: { error: "No recorded body for this component", reason: "CONTEXT_COMPONENT_UNAVAILABLE" } };
+        const bytes = await readFileBoundarySafe({ boundaryRoot: loaded.facts.runDir, targetPath: path.resolve(loaded.facts.runDir, ...component.materializedPath.split("/")), label: "recorded context component" });
+        if (bytes.byteLength !== component.bytes || createHash("sha256").update(bytes).digest("hex") !== component.sha256)
+            return { status: 422, body: { error: "Recorded context component has changed", reason: "CONTEXT_COMPONENT_UNAVAILABLE" } };
+        const raw = bytes.toString("utf8");
+        const safe = redactSensitivePathsWithFindings(redactSecrets(raw)).redacted;
+        const content = truncateUtf8Preview(safe, DAG_ARTIFACT_PREVIEW_MAX_BYTES);
+        return { status: 200, body: { dagRunId, nodeId, attempt, componentIndex, sourceBytes: bytes.byteLength, content, redacted: safe !== raw, truncated: content !== safe, maxBytes: DAG_ARTIFACT_PREVIEW_MAX_BYTES } };
+    }
     catch {
-        return {
-            status: 404,
-            body: { error: "Artifact file is unavailable", reason: "not-found" },
-        };
+        return { status: 422, body: { error: "Recorded context is unavailable or unsafe", reason: "CONTEXT_COMPONENT_UNAVAILABLE" } };
     }
 }
 function stringField(value, key) {

package/dist/worker/observe/routes.js

@@ -21,7 +21,7 @@ import { extractSpecEvidence, extractSpecReadContent, } from "./spec-evidence.js
 import { buildDagNodeInput } from "./node-input.js";
 import { loadDagNodeExecutionOutput } from "./dag-node-execution-output.js";
 import { loadDagNodeProcess } from "./node-process.js";
-import { loadDagNodeArtifactInventory, loadDagNodeArtifactPreview, loadDagNodeContextSummary, loadDagRunLineage, } from "./node-transparency.js";
+import { loadDagNodeArtifactInventory, loadDagNodeArtifactPreview, loadDagNodeArtifactDownload, loadDagNodeContextComponent, loadDagNodeContextSummary, loadDagRunLineage, } from "./node-transparency.js";
 import { buildObserveHealthV1 } from "./health.js";
 import { buildNightJobDetail, buildNightJobsDoctor, buildNightJobsList, buildNightJobsMorning, } from "./night-jobs.js";
 const ARTIFACT_PREVIEW_MAX_BYTES = 64 * 1024;
@@ -125,6 +125,8 @@ export const ROUTES = [
         pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/artifacts$/,
         handler: handleDagNodeArtifacts,
     },
+    { method: "GET", pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/context\/component$/, handler: handleDagNodeContextComponent },
+    { method: "GET", pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/artifacts\/download$/, handler: handleDagNodeArtifactDownload },
     {
         method: "GET",
         pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/execution-output$/,
@@ -795,6 +797,23 @@ async function handleDagNodeContext(_req, res, match, ctx) {
     const result = await loadDagNodeContextSummary(ctx.repoRoot, match.params.id, match.params.sub, attempt);
     sendJson(res, result.status, result.body);
 }
+async function handleDagNodeContextComponent(_req, res, match, ctx) {
+    if (!/^[1-9]\d*$/.test(match.query.get("attempt") ?? "") || !/^(0|[1-9]\d*)$/.test(match.query.get("componentIndex") ?? "") || match.query.has("path") || match.query.has("artifactPath")) {
+        sendJson(res, 400, { error: "Select a recorded attempt and component index" });
+        return;
+    }
+    const result = await loadDagNodeContextComponent(ctx.repoRoot, match.params.id, match.params.sub, Number(match.query.get("attempt")), Number(match.query.get("componentIndex")));
+    sendJson(res, result.status, result.body);
+}
+async function handleDagNodeArtifactDownload(_req, res, match, ctx) {
+    const result = await loadDagNodeArtifactDownload(ctx.repoRoot, match.params.id, match.params.sub, match.query.get("artifactId") ?? "");
+    if (result.status !== 200) {
+        sendJson(res, result.status, result.body);
+        return;
+    }
+    res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8", "Content-Disposition": `attachment; filename="${result.download.filename}"`, "Content-Length": result.download.bytes.byteLength, "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
+    res.end(result.download.bytes);
+}
 async function handleDagNodeArtifacts(_req, res, match, ctx) {
     const result = await loadDagNodeArtifactInventory(ctx.repoRoot, match.params.id, match.params.sub);
     sendJson(res, result.status, result.body);