Commit 7220dfe2c949476eaa7d21eccbcd3a0ce0eddb49 | the-knife

apps/mobile/package.json+1

...	@@ -128,6 +128,7 @@	...	@@ -128,6 +128,7 @@
128	"@effect/vitest": "catalog:",	128	"@effect/vitest": "catalog:",
129	"@pierre/trees": "1.0.0-beta.4",	129	"@pierre/trees": "1.0.0-beta.4",
130	"@types/react": "~19.2.0",	130	"@types/react": "~19.2.0",
		131	"@types/react-dom": "~19.2.3",
131	"babel-preset-expo": "~57.0.9",	132	"babel-preset-expo": "~57.0.9",
132	"tailwindcss": "^4.0.0",	133	"tailwindcss": "^4.0.0",
133	"typescript": "catalog:"	134	"typescript": "catalog:"

apps/mobile/src/features/threads/PendingUserInputCard.tsx+13-13

 @@ -1,3 +1,4 @@
+import { QuestionAttachments } from "./QuestionAttachments";
 import type { ApprovalRequestId, UserInputQuestion } from "@t3tools/contracts";
 import { useCallback, useRef } from "react";
 import { Platform, Pressable, ScrollView, View, type LayoutChangeEvent } from "react-native";
 @@ -15,7 +16,7 @@ import Animated, {
 import { USER_INPUT_TOGGLE_DURATION_MS } from "./pendingUserInputLayout";
 import { SymbolView } from "../../components/AppSymbol";
-import { AppText as Text, AppTextInput as TextInput } from "../../components/AppText";
+import { AppText as Text } from "../../components/AppText";
 import { ControlPill } from "../../components/ControlPill";
 import { cn } from "../../lib/cn";
 import {
 @@ -305,18 +306,17 @@ export function PendingUserInputCard(props: PendingUserInputCardProps) {
                   );
                 })}
               </View>
-              {question.allowCustomAnswer !== false ? (
+              <QuestionAttachments
-                <TextInput
+                requestId={props.pendingUserInput.requestId}
-                  value={draft?.customAnswer ?? ""}
+                question={question}
-                  onChangeText={(value) =>
+                questions={props.pendingUserInput.questions}
-                    props.onChangeCustomAnswer(props.pendingUserInput.requestId, question.id, value)
+                disabled={props.respondingUserInputId === props.pendingUserInput.requestId}
-                  }
+                value={draft?.customAnswer ?? ""}
-                  onFocus={() => props.onInputFocusChange?.(true)}
+                onChangeText={(value) =>
-                  onBlur={() => props.onInputFocusChange?.(false)}
+                  props.onChangeCustomAnswer(props.pendingUserInput.requestId, question.id, value)
-                  placeholder="Or type a custom answer"
+                }
-                  className="min-h-[54px] rounded-2xl border border-input-border bg-input px-3.5 py-3 font-sans text-base text-foreground"
+                onInputFocusChange={props.onInputFocusChange}
-                />
+              />
-              ) : null}
             </View>
           );
         })}

apps/mobile/src/features/threads/QuestionAnswerHistory.test.tsx created+58

...	@@ -0,0 +1,58 @@
1	import { ApprovalRequestId, EnvironmentId } from "@t3tools/contracts";
2	import type { ReactNode } from "react";
3	import { renderToStaticMarkup } from "react-dom/server";
4	import { describe, expect, it, vi } from "vite-plus/test";
5
6	vi.mock("react-native", () => ({
7	View: "div",
8	Pressable: ({ children }: { children: ReactNode }) => <button>{children}</button>,
9	Image: "img",
10	Linking: { openURL: vi.fn() },
11	}));
12	vi.mock("../../components/AppText", () => ({ AppText: "span" }));
13	vi.mock("../../state/assets", () => ({ useAssetUrl: () => null }));
14
15	import { QuestionAnswerHistory } from "./QuestionAnswerHistory";
16
17	describe("QuestionAnswerHistory", () => {
18	it.each([{}, { text: "Text-only answer", file: "Answer with a file" }])(
19	"renders attachment-only questions alongside text answers: %j",
20	(answers) => {
21	const markup = renderToStaticMarkup(
22	<QuestionAnswerHistory
23	environmentId={EnvironmentId.make("environment-local")}
24	answer={{
25	requestId: ApprovalRequestId.make("question-request"),
26	answers,
27	questionTextById: { file: "Provide a spec", image: "Provide a screenshot" },
28	attachmentsByQuestionId: {
29	file: [
30	{
31	type: "file",
32	id: "spec",
33	name: "spec.txt",
34	mimeType: "text/plain",
35	sizeBytes: 4,
36	},
37	],
38	image: [
39	{
40	type: "image",
41	id: "shot",
42	name: "shot.png",
43	mimeType: "image/png",
44	sizeBytes: 4,
45	},
46	],
47	},
48	}}
49	/>,
50	);
51	expect(markup.match(/Provide a spec/g)).toHaveLength(1);
52	expect(markup.match(/spec\.txt/g)).toHaveLength(1);
53	expect(markup).toContain("Provide a screenshot");
54	expect(markup).toContain("shot.png");
55	for (const answer of Object.values(answers)) expect(markup).toContain(answer);
56	},
57	);
58	});

apps/mobile/src/features/threads/QuestionAnswerHistory.tsx created+71

...	@@ -0,0 +1,71 @@
1	import type {
2	EnvironmentId,
3	UserInputAttachmentAnswerPayload,
4	UserInputAttachments,
5	} from "@t3tools/contracts";
6	import { Image, Linking, Pressable, View } from "react-native";
7	import { AppText as Text } from "../../components/AppText";
8	import { useAssetUrl } from "../../state/assets";
9
10	function AnswerFile(props: {
11	environmentId: EnvironmentId;
12	attachment: UserInputAttachments[string][number];
13	}) {
14	const url = useAssetUrl(props.environmentId, {
15	_tag: "attachment",
16	attachmentId: props.attachment.id,
17	});
18	return (
19	<Pressable
20	accessibilityRole="link"
21	accessibilityLabel={props.attachment.name}
22	disabled={!url}
23	onPress={() => {
24	if (url) void Linking.openURL(url);
25	}}
26	className="gap-1"
27	>
28	{props.attachment.type === "image" && url ? (
29	<Image source={{ uri: url }} style={{ width: 160, height: 96 }} resizeMode="contain" />
30	) : null}
31	<Text className="text-sm text-foreground underline">{props.attachment.name}</Text>
32	</Pressable>
33	);
34	}
35
36	export function QuestionAnswerHistory(props: {
37	environmentId: EnvironmentId;
38	answer: UserInputAttachmentAnswerPayload;
39	}) {
40	return (
41	<View className="gap-2">
42	{[
43	...new Set([
44	...Object.keys(props.answer.answers),
45	...Object.keys(props.answer.attachmentsByQuestionId),
46	]),
47	].map((questionId) => (
48	<View key={questionId} className="gap-1">
49	{props.answer.questionTextById?.[questionId] ? (
50	<Text className="text-sm text-foreground-muted">
51	{props.answer.questionTextById[questionId]}
52	</Text>
53	) : null}
54	<Text className="text-sm text-foreground">
55	{[props.answer.answers[questionId]]
56	.flat()
57	.filter((value): value is string => typeof value === "string")
58	.join(", ")}
59	</Text>
60	{(props.answer.attachmentsByQuestionId[questionId] ?? []).map((attachment) => (
61	<AnswerFile
62	key={attachment.id}
63	environmentId={props.environmentId}
64	attachment={attachment}
65	/>
66	))}
67	</View>
68	))}
69	</View>
70	);
71	}

apps/mobile/src/features/threads/QuestionAttachments.tsx created+183

...	@@ -0,0 +1,183 @@
1	import { TextInputWrapper } from "expo-paste-input";
2	import { AppTextInput as TextInput } from "../../components/AppText";
3	import { useNativePaste } from "../../lib/useNativePaste";
4	import { convertPastedImagesToAttachments } from "../../lib/composerImages";
5	import {
6	PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
7	type ApprovalRequestId,
8	type UserInputQuestion,
9	} from "@t3tools/contracts";
10	import { useAtomValue } from "@effect/atom-react";
11	import { Alert, View } from "react-native";
12	import { useEffect, useRef } from "react";
13	import { ComposerAttachmentButton } from "../../components/ComposerAttachmentButton";
14	import { ComposerAttachmentStrip } from "../../components/ComposerAttachmentStrip";
15	import { pickComposerFiles, pickComposerMedia } from "../../lib/composerImages";
16	import { useThreadSelection } from "../../state/use-thread-selection";
17	import { useServerConfigs } from "../../state/entities";
18	import { appAtomRegistry } from "../../state/atom-registry";
19	import {
20	appendComposerDraftAttachments,
21	composerDraftsAtom,
22	removeComposerDraftAttachment,
23	releaseUnusedComposerAttachmentFiles,
24	} from "../../state/use-composer-drafts";
25	import {
26	changeQuestionAttachmentPreparation,
27	questionAttachmentDraftKey,
28	questionAttachmentPreparationAtom,
29	} from "../../state/question-attachments";
30
31	export function QuestionAttachments(props: {
32	requestId: ApprovalRequestId;
33	question: UserInputQuestion;
34	questions: ReadonlyArray<UserInputQuestion>;
35	disabled: boolean;
36	value: string;
37	onChangeText: (value: string) => void;
38	onInputFocusChange?: ((focused: boolean) => void) \| undefined;
39	}) {
40	const { selectedThread } = useThreadSelection();
41	const configs = useServerConfigs();
42	const drafts = useAtomValue(composerDraftsAtom);
43	const scopeKey = JSON.stringify([
44	selectedThread?.environmentId,
45	selectedThread?.id,
46	props.requestId,
47	props.question.id,
48	]);
49	const pickerScope = useRef<{ key: string; active: boolean } \| null>(null);
50	useEffect(() => {
51	const scope = { key: scopeKey, active: true };
52	pickerScope.current = scope;
53	return () => {
54	scope.active = false;
55	};
56	}, [scopeKey]);
57	const append = (
58	key: string,
59	attachments: Parameters<typeof appendComposerDraftAttachments>[1],
60	) => {
61	if (!selectedThread) return 0;
62	const current = appAtomRegistry.get(composerDraftsAtom);
63	const otherCount = props.questions.reduce((count, question) => {
64	const target = questionAttachmentDraftKey(
65	selectedThread.environmentId,
66	selectedThread.id,
67	props.requestId,
68	question.id,
69	);
70	return target === key ? count : count + (current[target]?.attachments.length ?? 0);
71	}, 0);
72	return appendComposerDraftAttachments(key, attachments, {
73	maxAttachments: Math.max(0, PROVIDER_SEND_TURN_MAX_ATTACHMENTS - otherCount),
74	});
75	};
76	const paste = useNativePaste((uris) => {
77	const scope = pickerScope.current;
78	if (
79	!selectedThread \|\|
80	props.disabled \|\|
81	!configs.get(selectedThread.environmentId)?.environment.capabilities.questionAttachments
82	)
83	return;
84	const key = questionAttachmentDraftKey(
85	selectedThread.environmentId,
86	selectedThread.id,
87	props.requestId,
88	props.question.id,
89	);
90	changeQuestionAttachmentPreparation(key, 1);
91	void convertPastedImagesToAttachments({
92	uris,
93	existingCount: appAtomRegistry.get(composerDraftsAtom)[key]?.attachments.length ?? 0,
94	})
95	.then(async (images) => {
96	if (
97	scope?.active &&
98	(appAtomRegistry.get(questionAttachmentPreparationAtom)[key] ?? 0) > 0
99	) {
100	if (append(key, images) > 0)
101	Alert.alert("Could not paste image", "Too many attachments.");
102	} else await releaseUnusedComposerAttachmentFiles(images);
103	})
104	.catch((error) =>
105	Alert.alert("Could not paste image", error instanceof Error ? error.message : "Try again."),
106	)
107	.finally(() => changeQuestionAttachmentPreparation(key, -1));
108	});
109	if (!selectedThread \|\| props.question.allowCustomAnswer === false) return null;
110	const { environmentId, id: threadId } = selectedThread;
111	const capabilities = configs.get(environmentId)?.environment.capabilities;
112	const canAttach = capabilities?.questionAttachments === true;
113	const key = questionAttachmentDraftKey(
114	environmentId,
115	threadId,
116	props.requestId,
117	props.question.id,
118	);
119	const attachments = drafts[key]?.attachments ?? [];
120	const pick = async (kind: "media" \| "files") => {
121	const scope = pickerScope.current;
122	changeQuestionAttachmentPreparation(key, 1);
123	try {
124	const existingCount = appAtomRegistry.get(composerDraftsAtom)[key]?.attachments.length ?? 0;
125	const result =
126	kind === "files"
127	? await pickComposerFiles({
128	existingCount,
129	maxBytes: capabilities?.fileAttachments?.maxUploadBytes,
130	})
131	: await pickComposerMedia({
132	existingCount,
133	maxVideoBytes: capabilities?.fileAttachments?.maxUploadBytes,
134	});
135	const picked = "files" in result ? result.files : result.attachments;
136	// Resolution on another client clears the reservation while the picker is open.
137	if (
138	!scope?.active \|\|
139	(appAtomRegistry.get(questionAttachmentPreparationAtom)[key] ?? 0) === 0
140	) {
141	await releaseUnusedComposerAttachmentFiles(picked);
142	return;
143	}
144	const rejected = append(key, picked);
145	if (result.error \|\| rejected > 0)
146	Alert.alert("Could not attach file", result.error ?? "Too many attachments.");
147	} catch (error) {
148	Alert.alert("Could not attach file", error instanceof Error ? error.message : "Try again.");
149	} finally {
150	changeQuestionAttachmentPreparation(key, -1);
151	}
152	};
153	return (
154	<View className="gap-2">
155	{canAttach ? (
156	<ComposerAttachmentButton
157	disabled={props.disabled}
158	supportsFiles={Boolean(capabilities?.fileAttachments)}
159	onPickMedia={() => pick("media")}
160	onPickFiles={() => pick("files")}
161	/>
162	) : null}
163	<ComposerAttachmentStrip
164	environmentId={environmentId}
165	attachments={attachments}
166	onRemove={(id) => {
167	if (!props.disabled) removeComposerDraftAttachment(key, id);
168	}}
169	/>
170	<TextInputWrapper onPaste={paste}>
171	<TextInput
172	value={props.value}
173	editable={!props.disabled}
174	onChangeText={props.onChangeText}
175	onFocus={() => props.onInputFocusChange?.(true)}
176	onBlur={() => props.onInputFocusChange?.(false)}
177	placeholder="Or type a custom answer"
178	className="min-h-[54px] rounded-2xl border border-input-border bg-input px-3.5 py-3 font-sans text-base text-foreground"
179	/>
180	</TextInputWrapper>
181	</View>
182	);
183	}

apps/mobile/src/features/threads/thread-work-log.tsx+8-1

 @@ -1,3 +1,4 @@
+import { QuestionAnswerHistory } from "./QuestionAnswerHistory";
 import * as Haptics from "expo-haptics";
 import { Image } from "expo-image";
 import { type AppSymbolName, SymbolView } from "../../components/AppSymbol";
 @@ -849,13 +850,19 @@ const ThreadWorkLogRow = memo(function ThreadWorkLogRow(
         </View>
       </Pressable>
-      {expanded && (fullDetail || viewedImagePath) ? (
+      {expanded && (fullDetail || viewedImagePath || row.workEntry.questionAnswer) ? (
         <Animated.View
           entering={WORK_LOG_DETAIL_ENTER_TRANSITION}
           exiting={WORK_LOG_DETAIL_EXIT_TRANSITION}
           layout={WORK_LOG_LAYOUT_TRANSITION}
           className="ml-7 border-l border-adaptive-neutral-300-a60-white-a12 pb-1 pl-3 pt-0.5"
         >
+          {row.workEntry.questionAnswer ? (
+            <QuestionAnswerHistory
+              environmentId={props.environmentId}
+              answer={row.workEntry.questionAnswer}
+            />
+          ) : null}
           {viewedImagePath ? (
             <View className="pb-1.5">
               {props.renderImage({ href: viewedImagePath, alt: null, title: null })}

apps/mobile/src/lib/composerAttachmentUploadQueue.test.ts+26-1

...	@@ -1,5 +1,10 @@	...	@@ -1,5 +1,10 @@
1	import { EnvironmentId } from "@t3tools/contracts";	1	import { ApprovalRequestId, EnvironmentId, ThreadId } from "@t3tools/contracts";
2	import { describe, expect, it, vi } from "vite-plus/test";	2	import { describe, expect, it, vi } from "vite-plus/test";
		3	import {
		4	questionAttachmentDraftKey,
		5	questionAttachmentDraftPrefix,
		6	} from "../state/question-attachments";
		7	vi.mock("../state/atom-registry", () => ({ appAtomRegistry: {} }));
3		8
4	import {	9	import {
5	composerAttachmentUploadBlockReason,	10	composerAttachmentUploadBlockReason,
...	@@ -217,6 +222,26 @@ describe("composer attachment upload queue", () => {	...	@@ -217,6 +222,26 @@ describe("composer attachment upload queue", () => {
217	});	222	});
218		223
219	describe("draft upload scope and offline submission", () => {	224	describe("draft upload scope and offline submission", () => {
		225	it("uploads question drafts in their environment without matching other thread prefixes", () => {
		226	const requestId = ApprovalRequestId.make("request:1");
		227	for (const environment of [environmentId, EnvironmentId.make("remote:server")]) {
		228	const threadId = ThreadId.make("thread:1");
		229	const prefix = questionAttachmentDraftPrefix(environment, threadId);
		230	const key = questionAttachmentDraftKey(environment, threadId, requestId, "question:1");
		231	expect(composerDraftEnvironmentId(key, [])).toBe(environment);
		232	expect(key.startsWith(prefix)).toBe(true);
		233	for (const suffix of ["-extra", ":extra", "/extra", "%extra"]) {
		234	const otherKey = questionAttachmentDraftKey(
		235	environment,
		236	ThreadId.make(`${threadId}${suffix}`),
		237	requestId,
		238	"question:1",
		239	);
		240	expect(otherKey.startsWith(prefix)).toBe(false);
		241	expect(composerDraftEnvironmentId(otherKey, [])).toBe(environment);
		242	}
		243	}
		244	});
220	it("resolves thread, new-task, and queued-task drafts without crossing environments", () => {	245	it("resolves thread, new-task, and queued-task drafts without crossing environments", () => {
221	expect(composerDraftEnvironmentId("environment-1:thread", [])).toBe(environmentId);	246	expect(composerDraftEnvironmentId("environment-1:thread", [])).toBe(environmentId);
222	expect(composerDraftEnvironmentId("new-task:environment-1:project", [])).toBe(environmentId);	247	expect(composerDraftEnvironmentId("new-task:environment-1:project", [])).toBe(environmentId);

apps/mobile/src/lib/threadActivity.test.ts+70

...	@@ -2,6 +2,7 @@ import { derivePendingRequests } from "@t3tools/client-runtime/pending-requests"	...	@@ -2,6 +2,7 @@ import { derivePendingRequests } from "@t3tools/client-runtime/pending-requests"
2	import { describe, expect, it } from "vite-plus/test";	2	import { describe, expect, it } from "vite-plus/test";
3		3
4	import {	4	import {
		5	ApprovalRequestId,
5	EventId,	6	EventId,
6	MessageId,	7	MessageId,
7	ProjectId,	8	ProjectId,
...	@@ -3314,3 +3315,72 @@ describe("quiet timeline: nested agents", () => {	...	@@ -3314,3 +3315,72 @@ describe("quiet timeline: nested agents", () => {
3314	]);	3315	]);
3315	});	3316	});
3316	});	3317	});
		3318
		3319	it("accepts ready attachment-only answers while preserving selected options", () => {
		3320	const question = {
		3321	id: "q",
		3322	header: "Spec",
		3323	question: "Provide a specification",
		3324	options: [{ label: "Yes", description: "Approve" }],
		3325	multiSelect: false,
		3326	};
		3327	expect(buildPendingUserInputAnswers([question], { q: { attachmentCount: 1 } })).toEqual({
		3328	q: "",
		3329	});
		3330	expect(
		3331	buildPendingUserInputAnswers([question], {
		3332	q: { attachmentCount: 1, selectedOptionValues: ["Yes"] },
		3333	}),
		3334	).toEqual({ q: "Yes" });
		3335	expect(
		3336	buildPendingUserInputAnswers([question], {
		3337	q: { attachmentCount: 1, attachmentsBlocked: true },
		3338	}),
		3339	).toBeNull();
		3340	expect(
		3341	buildPendingUserInputAnswers([{ ...question, allowCustomAnswer: false }], {
		3342	q: { attachmentCount: 1 },
		3343	}),
		3344	).toBeNull();
		3345	});
		3346
		3347	it("makes attachment-only question answers expandable in the mobile feed", () => {
		3348	const answer = {
		3349	requestId: ApprovalRequestId.make("question-request"),
		3350	answers: { q: "" },
		3351	questionTextById: { q: "Attach the specification" },
		3352	attachmentsByQuestionId: {
		3353	q: [
		3354	{
		3355	type: "file" as const,
		3356	id: "question-file",
		3357	name: "spec.txt",
		3358	mimeType: "text/plain",
		3359	sizeBytes: 4,
		3360	},
		3361	],
		3362	},
		3363	};
		3364	const thread = makeThread({
		3365	id: ThreadId.make("thread-answer"),
		3366	projectId: ProjectId.make("project-answer"),
		3367	title: "Answer history",
		3368	activities: [
		3369	makeActivity({
		3370	id: EventId.make("answer-submitted"),
		3371	createdAt: "2026-09-08T00:00:00.000Z",
		3372	kind: "user-input.answer-submitted",
		3373	summary: "Answered questions",
		3374	payload: answer,
		3375	}),
		3376	],
		3377	});
		3378	const [group] = buildThreadFeed(thread);
		3379	expect(group?.type).toBe("activity-group");
		3380	if (group?.type !== "activity-group") return;
		3381	expect(group.activities[0]).toMatchObject({
		3382	canExpand: true,
		3383	workEntry: { questionAnswer: answer },
		3384	});
		3385	expect(group.activities[0]?.getFullDetail()).toBeNull();
		3386	});

apps/mobile/src/lib/threadActivity.ts+24-3

 @@ -1,8 +1,10 @@
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
 import {
   requestKindFromRequestType,
   type PendingApproval,
 } from "@t3tools/client-runtime/pending-requests";
-import { isToolLifecycleItemType } from "@t3tools/contracts";
+import { UserInputAttachmentAnswerPayload, isToolLifecycleItemType } from "@t3tools/contracts";
 import type {
   OrchestrationLatestTurn,
   OrchestrationThread,
 @@ -41,6 +43,8 @@ export type { PendingApproval, PendingUserInput } from "@t3tools/client-runtime/
 export interface PendingUserInputDraftAnswer {
   readonly selectedOptionValues?: ReadonlyArray<string>;
   readonly customAnswer?: string;
+  readonly attachmentCount?: number;
+  readonly attachmentsBlocked?: boolean;
 }
 export interface ThreadFeedActivity {
 @@ -76,6 +80,7 @@ export interface ThreadFeedActivity {
 }
 export interface WorkLogEntry {
+  readonly questionAnswer?: UserInputAttachmentAnswerPayload;
   id: string;
   createdAt: string;
   turnId: TurnId | null;
 @@ -302,6 +307,7 @@ function resolvePendingUserInputAnswer(
   question: UserInputQuestion,
   draft: PendingUserInputDraftAnswer | undefined,
 ): string | ReadonlyArray<string> | null {
+  if (draft?.attachmentsBlocked) return null;
   const customAnswer =
     question.allowCustomAnswer === false ? null : normalizeDraftAnswer(draft?.customAnswer);
   if (customAnswer) {
 @@ -310,9 +316,16 @@ function resolvePendingUserInputAnswer(
   const selectedOptionValues = normalizeSelectedOptionValues(question, draft?.selectedOptionValues);
   if (question.multiSelect) {
-    return selectedOptionValues.length > 0 ? selectedOptionValues : null;
+    return selectedOptionValues.length > 0
+      ? selectedOptionValues
+      : question.allowCustomAnswer !== false && (draft?.attachmentCount ?? 0) > 0
+        ? ""
+        : null;
   }
-  return selectedOptionValues[0] ?? null;
+  return (
+    selectedOptionValues[0] ??
+    (question.allowCustomAnswer !== false && (draft?.attachmentCount ?? 0) > 0 ? "" : null)
+  );
 }
 /** Some providers settle agents through task.updated instead of task.completed. */
 @@ -435,6 +448,8 @@ function isPlanBoundaryToolActivity(activity: OrchestrationThreadActivity): bool
   return typeof payload?.detail === "string" && payload.detail.startsWith("ExitPlanMode:");
 }
+const decodeQuestionAttachmentAnswer = Schema.decodeUnknownOption(UserInputAttachmentAnswerPayload);
 function toDerivedWorkLogEntry(activity: OrchestrationThreadActivity): DerivedWorkLogEntry {
   const payload =
     activity.payload && typeof activity.payload === "object"
 @@ -480,6 +495,11 @@ function toDerivedWorkLogEntry(activity: OrchestrationThreadActivity): DerivedWo
           ? "info"
           : activity.tone,
     sourceActivityKind: activity.kind,
+    ...(() => {
+      if (activity.kind !== "user-input.answer-submitted") return {};
+      const answer = decodeQuestionAttachmentAnswer(activity.payload);
+      return Option.isSome(answer) ? { questionAnswer: answer.value } : {};
+    })(),
   };
   const toolCallId =
     asTrimmedString(payload?.toolCallId) ?? asTrimmedString(asRecord(payload?.data)?.toolCallId);
 @@ -969,6 +989,7 @@ function buildWorkEntryExpandedBody(entry: WorkLogEntry): string | null {
  * for every row (see the deferred-expansion test).
  */
 function workEntryCanExpand(entry: WorkLogEntry): boolean {
+  if (entry.questionAnswer) return true;
   if (entry.agentSpawn) return agentSpawnMembers(entry.agentSpawn).length > 0;
   if (entry.itemType === "mcp_tool_call" && entry.toolData !== undefined) return true;
   if (entry.changedFiles?.some((path) => path.trim().length > 0)) return true;

apps/mobile/src/state/question-attachments.ts created+29

...	@@ -0,0 +1,29 @@
1	import type { ApprovalRequestId, EnvironmentId, ThreadId } from "@t3tools/contracts";
2	import { Atom } from "effect/unstable/reactivity";
3	import { appAtomRegistry } from "./atom-registry";
4
5	export function questionAttachmentDraftPrefix(
6	environmentId: EnvironmentId,
7	threadId: ThreadId,
8	): string {
9	return `${environmentId}:question-${encodeURIComponent(JSON.stringify(threadId))}-`;
10	}
11	export function questionAttachmentDraftKey(
12	environmentId: EnvironmentId,
13	threadId: ThreadId,
14	requestId: ApprovalRequestId,
15	questionId: string,
16	): string {
17	return `${questionAttachmentDraftPrefix(environmentId, threadId)}${encodeURIComponent(JSON.stringify([requestId, questionId]))}`;
18	}
19	export const questionAttachmentPreparationAtom = Atom.make<Record<string, number>>({}).pipe(
20	Atom.keepAlive,
21	);
22	export function changeQuestionAttachmentPreparation(key: string, delta: number): void {
23	const counts = appAtomRegistry.get(questionAttachmentPreparationAtom);
24	if (delta < 0 && !(key in counts)) return;
25	appAtomRegistry.set(questionAttachmentPreparationAtom, {
26	...counts,
27	[key]: Math.max(0, (counts[key] ?? 0) + delta),
28	});
29	}

apps/mobile/src/state/use-composer-drafts.ts+8-2

 @@ -925,7 +925,7 @@ export function appendComposerDraftText(draftKey: string, value: string): void {
 export function appendComposerDraftAttachments(
   draftKey: string,
   attachments: ReadonlyArray<DraftComposerAttachment>,
-  options?: { readonly allowOverflow?: boolean },
+  options?: { readonly allowOverflow?: boolean; readonly maxAttachments?: number },
 ): number {
   if (attachments.length === 0) {
     return 0;
 @@ -935,7 +935,13 @@ export function appendComposerDraftAttachments(
     const existing = normalizeDraft(current[draftKey]);
     const remaining = options?.allowOverflow
       ? attachments.length
-      : Math.max(0, PROVIDER_SEND_TURN_MAX_ATTACHMENTS - existing.attachments.length);
+      : Math.max(
+          0,
+          Math.min(
+            PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
+            options?.maxAttachments ?? PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
+          ) - existing.attachments.length,
+        );
     const accepted = attachments.slice(0, remaining);
     rejected = attachments.slice(remaining);
     if (accepted.length === 0) {

apps/mobile/src/state/use-selected-thread-requests.test.tsx created+140

...	@@ -0,0 +1,140 @@
1	import { renderToStaticMarkup } from "react-dom/server";
2	import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
3
4	const fixture = vi.hoisted(() => ({
5	drafts: {} as Record<string, unknown>,
6	uploads: {} as Record<string, unknown>,
7	preparations: {} as Record<string, number>,
8	preparationAtom: Symbol("preparation"),
9	}));
10	vi.mock("react-native", () => ({ Alert: { alert: vi.fn() } }));
11	vi.mock("@effect/atom-react", () => ({
12	useAtomValue: (atom: unknown) =>
13	atom === "drafts"
14	? fixture.drafts
15	: atom === "uploads"
16	? fixture.uploads
17	: atom === fixture.preparationAtom
18	? fixture.preparations
19	: {},
20	}));
21	vi.mock("./use-composer-drafts", () => ({
22	composerDraftsAtom: "drafts",
23	clearComposerDraft: vi.fn(),
24	}));
25	vi.mock("./composer-attachment-uploads", async () => ({
26	...(await import("../lib/composerAttachmentUploadQueue")),
27	composerAttachmentUploadsAtom: "uploads",
28	}));
29	vi.mock("./question-attachments", async (importOriginal) => ({
30	...(await importOriginal<typeof import("./question-attachments")>()),
31	questionAttachmentPreparationAtom: fixture.preparationAtom,
32	}));
33	vi.mock("./entities", () => ({
34	useServerConfigs: () =>
35	new Map([
36	[
37	"environment-1",
38	{
39	environment: {
40	capabilities: {
41	questionAttachments: true,
42	attachmentUploads: true,
43	fileAttachments: { maxUploadBytes: 20_000_000 },
44	},
45	},
46	},
47	],
48	]),
49	}));
50	vi.mock("./threads", () => ({ threadEnvironment: {} }));
51	vi.mock("./use-atom-command", () => ({ useAtomCommand: () => vi.fn() }));
52	vi.mock("./use-thread-selection", () => ({
53	useThreadSelection: () => ({
54	selectedThread: { environmentId: "environment-1", id: "thread-1" },
55	}),
56	}));
57	vi.mock("./use-thread-detail", () => ({
58	useSelectedThreadDetail: () => ({
59	activities: [
60	{
61	id: "request-activity",
62	kind: "user-input.requested",
63	createdAt: "2026-09-08T00:00:00Z",
64	payload: {
65	requestId: "request-1",
66	questions: ["first", "second"].map((id) => ({
67	id,
68	header: id,
69	question: `Attach ${id} file`,
70	options: [],
71	allowCustomAnswer: true,
72	})),
73	},
74	},
75	],
76	}),
77	}));
78
79	import { ApprovalRequestId, EnvironmentId, ThreadId } from "@t3tools/contracts";
80	import { questionAttachmentDraftKey } from "./question-attachments";
81	import { useSelectedThreadRequests } from "./use-selected-thread-requests";
82
83	const environmentId = EnvironmentId.make("environment-1");
84	const key = (question: string) =>
85	questionAttachmentDraftKey(
86	environmentId,
87	ThreadId.make("thread-1"),
88	ApprovalRequestId.make("request-1"),
89	question,
90	);
91	function submitButtonMarkup() {
92	function Probe() {
93	const { activePendingUserInputAnswers } = useSelectedThreadRequests();
94	return <button disabled={activePendingUserInputAnswers === null}>Submit answers</button>;
95	}
96	return renderToStaticMarkup(<Probe />);
97	}
98	beforeEach(() => {
99	fixture.preparations = {};
100	fixture.drafts = Object.fromEntries(
101	["first", "second"].map((id) => [
102	key(id),
103	{
104	attachments: [
105	{
106	id,
107	type: "file",
108	name: `${id}.txt`,
109	mimeType: "text/plain",
110	sizeBytes: 4,
111	fileUri: `file:///${id}.txt`,
112	},
113	],
114	},
115	]),
116	);
117	fixture.uploads = { "environment-1:first": { status: "ready" } };
118	});
119	describe("question attachment submission readiness", () => {
120	it.each([
121	undefined,
122	{ status: "uploading", progress: 0.5 },
123	{ status: "failed", reason: "Offline" },
124	])("keeps Submit disabled until all question uploads finish: %j", (state) => {
125	if (state) fixture.uploads["environment-1:second"] = state;
126	expect(submitButtonMarkup()).toContain("disabled");
127	fixture.uploads["environment-1:second"] = { status: "ready" };
128	expect(submitButtonMarkup()).not.toContain("disabled");
129	});
130	it("ignores an upload in another environment", () => {
131	fixture.uploads["environment-1:second"] = { status: "ready" };
132	fixture.uploads["environment-2:second"] = { status: "uploading", progress: 0.5 };
133	expect(submitButtonMarkup()).not.toContain("disabled");
134	});
135	it("waits for attachment preparation even when uploads are ready", () => {
136	fixture.uploads["environment-1:second"] = { status: "ready" };
137	fixture.preparations[key("first")] = 1;
138	expect(submitButtonMarkup()).toContain("disabled");
139	});
140	});

apps/mobile/src/state/use-selected-thread-requests.ts+138-4

...	@@ -1,6 +1,19 @@	...	@@ -1,6 +1,19 @@
1	import { derivePendingRequests } from "@t3tools/client-runtime/pending-requests";	1	import { derivePendingRequests } from "@t3tools/client-runtime/pending-requests";
		2	import { useServerConfigs } from "./entities";
		3	import { Alert } from "react-native";
		4	import {
		5	questionAttachmentDraftKey,
		6	questionAttachmentDraftPrefix,
		7	questionAttachmentPreparationAtom,
		8	} from "./question-attachments";
		9	import { composerDraftsAtom, clearComposerDraft } from "./use-composer-drafts";
		10	import {
		11	composerAttachmentUploadsAtom,
		12	composerAttachmentUploadBlockReason,
		13	composerAttachmentsStillUploading,
		14	} from "./composer-attachment-uploads";
2	import { useAtomValue } from "@effect/atom-react";	15	import { useAtomValue } from "@effect/atom-react";
3	import { useCallback, useMemo, useState } from "react";	16	import { useCallback, useEffect, useMemo, useRef, useState } from "react";
4		17
5	import {	18	import {
6	ApprovalRequestId,	19	ApprovalRequestId,
...	@@ -81,6 +94,7 @@ export function useSelectedThreadRequests() {	...	@@ -81,6 +94,7 @@ export function useSelectedThreadRequests() {
81	const selectedThread = useSelectedThreadDetail();	94	const selectedThread = useSelectedThreadDetail();
82	const userInputDraftsByRequestKey = useAtomValue(userInputDraftsByRequestKeyAtom);	95	const userInputDraftsByRequestKey = useAtomValue(userInputDraftsByRequestKeyAtom);
83	const [respondingApprovalId, setRespondingApprovalId] = useState<ApprovalRequestId \| null>(null);	96	const [respondingApprovalId, setRespondingApprovalId] = useState<ApprovalRequestId \| null>(null);
		97	const userInputResponsesInFlight = useRef(new Set<string>());
84	const [respondingUserInputId, setRespondingUserInputId] = useState<ApprovalRequestId \| null>(	98	const [respondingUserInputId, setRespondingUserInputId] = useState<ApprovalRequestId \| null>(
85	null,	99	null,
86	);	100	);
...	@@ -91,11 +105,81 @@ export function useSelectedThreadRequests() {	...	@@ -91,11 +105,81 @@ export function useSelectedThreadRequests() {
91	);	105	);
92	const activePendingApproval = activePendingApprovals[0] ?? null;	106	const activePendingApproval = activePendingApprovals[0] ?? null;
93	const activePendingUserInput = activePendingUserInputs[0] ?? null;	107	const activePendingUserInput = activePendingUserInputs[0] ?? null;
		108	const questionServerConfigs = useServerConfigs();
		109	const attachmentDrafts = useAtomValue(composerDraftsAtom);
		110	const preparationCounts = useAtomValue(questionAttachmentPreparationAtom);
		111	const uploadStates = useAtomValue(composerAttachmentUploadsAtom);
		112	useEffect(() => {
		113	if (!selectedThreadShell \|\| !selectedThread) return;
		114	const prefix = questionAttachmentDraftPrefix(
		115	selectedThreadShell.environmentId,
		116	selectedThreadShell.id,
		117	);
		118	const retained = new Set(
		119	activePendingUserInputs.flatMap((request) =>
		120	request.questions.map((question) =>
		121	questionAttachmentDraftKey(
		122	selectedThreadShell.environmentId,
		123	selectedThreadShell.id,
		124	request.requestId,
		125	question.id,
		126	),
		127	),
		128	),
		129	);
		130	const counts = { ...appAtomRegistry.get(questionAttachmentPreparationAtom) };
		131	let changed = false;
		132	for (const key of new Set([...Object.keys(attachmentDrafts), ...Object.keys(counts)])) {
		133	if (!key.startsWith(prefix) \|\| retained.has(key)) continue;
		134	if (attachmentDrafts[key]) clearComposerDraft(key);
		135	if (key in counts) {
		136	delete counts[key];
		137	changed = true;
		138	}
		139	}
		140	if (changed) appAtomRegistry.set(questionAttachmentPreparationAtom, counts);
		141	}, [activePendingUserInputs, attachmentDrafts, selectedThread, selectedThreadShell]);
94	const activePendingUserInputDrafts =	142	const activePendingUserInputDrafts =
95	activePendingUserInput && selectedThreadShell	143	activePendingUserInput && selectedThreadShell
96	? (userInputDraftsByRequestKey[	144	? Object.fromEntries(
97	scopedRequestKey(selectedThreadShell.environmentId, activePendingUserInput.requestId)	145	activePendingUserInput.questions.map((question) => {
98	] ?? {})	146	const key = questionAttachmentDraftKey(
		147	selectedThreadShell.environmentId,
		148	selectedThreadShell.id,
		149	activePendingUserInput.requestId,
		150	question.id,
		151	);
		152	const attachments = attachmentDrafts[key]?.attachments ?? [];
		153	const uploadInput = {
		154	environmentId: selectedThreadShell.environmentId,
		155	attachments,
		156	serverConfig: questionServerConfigs.get(selectedThreadShell.environmentId) ?? null,
		157	states: uploadStates,
		158	};
		159	return [
		160	question.id,
		161	{
		162	...userInputDraftsByRequestKey[
		163	scopedRequestKey(
		164	selectedThreadShell.environmentId,
		165	activePendingUserInput.requestId,
		166	)
		167	]?.[question.id],
		168	attachmentCount: attachments.length,
		169	attachmentsBlocked:
		170	(attachments.length > 0 &&
		171	questionServerConfigs.get(selectedThreadShell.environmentId)?.environment
		172	.capabilities.questionAttachments !== true) \|\|
		173	(preparationCounts[key] ?? 0) > 0 \|\|
		174	composerAttachmentsStillUploading(uploadInput) \|\|
		175	composerAttachmentUploadBlockReason({
		176	...uploadInput,
		177	connected: true,
		178	}) !== null,
		179	},
		180	];
		181	}),
		182	)
99	: {};	183	: {};
100	const activePendingUserInputAnswers = activePendingUserInput	184	const activePendingUserInputAnswers = activePendingUserInput
101	? buildPendingUserInputAnswers(activePendingUserInput.questions, activePendingUserInputDrafts)	185	? buildPendingUserInputAnswers(activePendingUserInput.questions, activePendingUserInputDrafts)
...	@@ -154,6 +238,52 @@ export function useSelectedThreadRequests() {	...	@@ -154,6 +238,52 @@ export function useSelectedThreadRequests() {
154	return;	238	return;
155	}	239	}
156		240
		241	const responseKey = questionAttachmentDraftKey(
		242	selectedThreadShell.environmentId,
		243	selectedThreadShell.id,
		244	activePendingUserInput.requestId,
		245	"",
		246	);
		247	if (userInputResponsesInFlight.current.has(responseKey)) return;
		248	const attachmentsByQuestionId = new Map<
		249	string,
		250	import("@t3tools/contracts").UserInputAttachments[string]
		251	>();
		252	for (const question of activePendingUserInput.questions) {
		253	const key = questionAttachmentDraftKey(
		254	selectedThreadShell.environmentId,
		255	selectedThreadShell.id,
		256	activePendingUserInput.requestId,
		257	question.id,
		258	);
		259	if ((appAtomRegistry.get(questionAttachmentPreparationAtom)[key] ?? 0) > 0) return;
		260	const attachments = appAtomRegistry.get(composerDraftsAtom)[key]?.attachments ?? [];
		261	if (attachments.length === 0) continue;
		262	if (
		263	attachments.some(
		264	(attachment) =>
		265	!attachment.uploadedAttachmentId \|\|
		266	attachment.uploadEnvironmentId !== selectedThreadShell.environmentId,
		267	)
		268	) {
		269	Alert.alert(
		270	"Attachments are not ready",
		271	"Wait for uploads to finish, or retry failed uploads.",
		272	);
		273	return;
		274	}
		275	attachmentsByQuestionId.set(
		276	question.id,
		277	attachments.map((attachment) => ({
		278	type: attachment.type,
		279	id: attachment.uploadedAttachmentId!,
		280	name: attachment.name,
		281	mimeType: attachment.mimeType,
		282	sizeBytes: attachment.sizeBytes,
		283	})),
		284	);
		285	}
		286	userInputResponsesInFlight.current.add(responseKey);
157	setRespondingUserInputId(activePendingUserInput.requestId);	287	setRespondingUserInputId(activePendingUserInput.requestId);
158	const result = await respondToUserInput({	288	const result = await respondToUserInput({
159	environmentId: selectedThreadShell.environmentId,	289	environmentId: selectedThreadShell.environmentId,
...	@@ -161,8 +291,12 @@ export function useSelectedThreadRequests() {	...	@@ -161,8 +291,12 @@ export function useSelectedThreadRequests() {
161	threadId: selectedThreadShell.id,	291	threadId: selectedThreadShell.id,
162	requestId: activePendingUserInput.requestId,	292	requestId: activePendingUserInput.requestId,
163	answers: activePendingUserInputAnswers,	293	answers: activePendingUserInputAnswers,
		294	...(attachmentsByQuestionId.size > 0
		295	? { attachmentsByQuestionId: Object.fromEntries(attachmentsByQuestionId) }
		296	: {}),
164	},	297	},
165	});	298	});
		299	userInputResponsesInFlight.current.delete(responseKey);
166	setRespondingUserInputId((current) =>	300	setRespondingUserInputId((current) =>
167	current === activePendingUserInput.requestId ? null : current,	301	current === activePendingUserInput.requestId ? null : current,
168	);	302	);

apps/server/src/environment/ServerEnvironment.ts+1

...	@@ -215,6 +215,7 @@ export const make = Effect.gen(function* () {	...	@@ -215,6 +215,7 @@ export const make = Effect.gen(function* () {
215	repositoryIdentity: true,	215	repositoryIdentity: true,
216	connectionProbe: true,	216	connectionProbe: true,
217	attachmentUploads: true,	217	attachmentUploads: true,
		218	questionAttachments: true,
218	fileAttachments: { maxUploadBytes: PROVIDER_SEND_TURN_MAX_FILE_BYTES },	219	fileAttachments: { maxUploadBytes: PROVIDER_SEND_TURN_MAX_FILE_BYTES },
219	pullRequests: true,	220	pullRequests: true,
220	threadSettlement: true,	221	threadSettlement: true,

apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts+13-1

 @@ -239,6 +239,17 @@ describe("OrchestrationEngine", () => {
           threadId,
           requestId,
           answers: { "0": "pnpm", "1": "Example" },
+          attachmentsByQuestionId: {
+            "1": [
+              {
+                type: "file" as const,
+                id: "thread-1-00000000-0000-4000-8000-0000000000aa-txt",
+                name: "spec.txt",
+                mimeType: "text/plain",
+                sizeBytes: 4,
+              },
+            ],
+          },
           createdAt: "2026-01-01T00:00:02.000Z",
         };
         await expect(
 @@ -256,8 +267,9 @@ describe("OrchestrationEngine", () => {
           (message) => message.role === "user",
         );
         expect(userMessages).toHaveLength(1);
+        expect(userMessages?.[0]?.attachments).toEqual(response.attachmentsByQuestionId["1"]);
         expect(userMessages?.[0]?.text).toBe(
-          "Which package manager?\npnpm\n\nWhat should it be named?\nExample",
+          "Which package manager?\npnpm\n\nWhat should it be named?\nExample\nAttached file: spec.txt (thread-1-00000000-0000-4000-8000-0000000000aa-txt)",
         );
         expect(
           after.threads[0]?.activities.find((activity) => activity.kind === "user-input.resolved")

apps/server/src/orchestration/Layers/ProjectionPipeline.test.ts+109-7

...	@@ -411,7 +411,7 @@ it.layer(BaseTestLayer)("OrchestrationProjectionPipeline", (it) => {	...	@@ -411,7 +411,7 @@ it.layer(BaseTestLayer)("OrchestrationProjectionPipeline", (it) => {
411	FROM projection_state	411	FROM projection_state
412	ORDER BY projector ASC	412	ORDER BY projector ASC
413	`;	413	`;
414	assert.equal(stateRows.length, Object.keys(ORCHESTRATION_PROJECTOR_NAMES).length);	414	assert.equal(stateRows.length, Object.keys(ORCHESTRATION_PROJECTOR_NAMES).length + 1);
415	for (const row of stateRows) {	415	for (const row of stateRows) {
416	assert.equal(row.lastAppliedSequence, 3);	416	assert.equal(row.lastAppliedSequence, 3);
417	}	417	}
...	@@ -1164,14 +1164,18 @@ it.layer(	...	@@ -1164,14 +1164,18 @@ it.layer(
1164		1164
1165	yield* projectionPipeline.bootstrap;	1165	yield* projectionPipeline.bootstrap;
1166	yield* projectionPipeline.bootstrap;	1166	yield* projectionPipeline.bootstrap;
1167	assert.deepEqual(	1167	assert.deepEqual(yield* projectionState.listAll(), [
1168	yield* projectionState.listAll(),	1168	{
1169	cursorsBeforeFailure.map((cursor) => ({	1169	projector: "projection.attachment-cleanup",
		1170	lastAppliedSequence: pendingEvent.sequence,
		1171	updatedAt: pendingEvent.occurredAt,
		1172	},
		1173	...cursorsBeforeFailure.map((cursor) => ({
1170	...cursor,	1174	...cursor,
1171	lastAppliedSequence: pendingEvent.sequence,	1175	lastAppliedSequence: pendingEvent.sequence,
1172	updatedAt: pendingEvent.occurredAt,	1176	updatedAt: pendingEvent.occurredAt,
1173	})),	1177	})),
1174	);	1178	]);
1175	const replayedMessages = yield* sql<{ readonly text: string }>`	1179	const replayedMessages = yield* sql<{ readonly text: string }>`
1176	SELECT text FROM projection_thread_messages WHERE message_id = 'message-rollback'	1180	SELECT text FROM projection_thread_messages WHERE message_id = 'message-rollback'
1177	`;	1181	`;
...	@@ -1364,10 +1368,53 @@ it.layer(	...	@@ -1364,10 +1368,53 @@ it.layer(
1364	},	1368	},
1365	});	1369	});
1366		1370
		1371	const answerKeepId = "thread-revert-files-00000000-0000-4000-8000-000000000006-txt";
		1372	const answerRemoveId = "thread-revert-files-00000000-0000-4000-8000-000000000007-txt";
		1373	for (const [id, turnId] of [
		1374	[answerKeepId, "turn-keep"],
		1375	[answerRemoveId, "turn-remove"],
		1376	] as const) {
		1377	yield* appendAndProject({
		1378	type: "thread.activity-appended",
		1379	eventId: EventId.make(`answer-${id}`),
		1380	aggregateKind: "thread",
		1381	aggregateId: threadId,
		1382	occurredAt: now,
		1383	commandId: CommandId.make(`answer-${id}`),
		1384	causationEventId: null,
		1385	correlationId: CorrelationId.make(`answer-${id}`),
		1386	metadata: {},
		1387	payload: {
		1388	threadId,
		1389	activity: {
		1390	id: EventId.make(`answer-${id}`),
		1391	kind: "user-input.answer-submitted",
		1392	tone: "info",
		1393	summary: "Answer with file",
		1394	createdAt: now,
		1395	turnId: TurnId.make(turnId),
		1396	payload: {
		1397	requestId: ApprovalRequestId.make(id),
		1398	answers: { q: "See file" },
		1399	attachmentsByQuestionId: {
		1400	q: [
		1401	{ type: "file", id, name: "answer.txt", mimeType: "text/plain", sizeBytes: 6 },
		1402	],
		1403	},
		1404	},
		1405	},
		1406	},
		1407	});
		1408	}
1367	const keepPath = path.join(attachmentsDir, `${keepAttachmentId}.png`);	1409	const keepPath = path.join(attachmentsDir, `${keepAttachmentId}.png`);
1368	const keepFilePath = path.join(attachmentsDir, `${keepFileAttachmentId}.pdf`);	1410	const keepFilePath = path.join(attachmentsDir, `${keepFileAttachmentId}.pdf`);
1369	const removePath = path.join(attachmentsDir, `${removeAttachmentId}.png`);	1411	const removePath = path.join(attachmentsDir, `${removeAttachmentId}.png`);
1370	yield* fileSystem.makeDirectory(attachmentsDir, { recursive: true });	1412	yield* fileSystem.makeDirectory(attachmentsDir, { recursive: true });
		1413	yield* fileSystem.writeFileString(path.join(attachmentsDir, `${answerKeepId}.txt`), "answer");
		1414	yield* fileSystem.writeFileString(
		1415	path.join(attachmentsDir, `${answerRemoveId}.txt`),
		1416	"answer",
		1417	);
1371	yield* fileSystem.writeFileString(keepPath, "keep");	1418	yield* fileSystem.writeFileString(keepPath, "keep");
1372	yield* fileSystem.writeFileString(keepFilePath, "keep");	1419	yield* fileSystem.writeFileString(keepFilePath, "keep");
1373	yield* fileSystem.writeFileString(removePath, "remove");	1420	yield* fileSystem.writeFileString(removePath, "remove");
...	@@ -1460,9 +1507,33 @@ it.layer(	...	@@ -1460,9 +1507,33 @@ it.layer(
1460		1507
1461	assert.isTrue(yield* exists(keepPath));	1508	assert.isTrue(yield* exists(keepPath));
1462	assert.isTrue(yield* exists(keepFilePath));	1509	assert.isTrue(yield* exists(keepFilePath));
		1510	assert.isTrue(yield* exists(path.join(attachmentsDir, `${answerKeepId}.txt`)));
		1511	assert.isFalse(yield* exists(path.join(attachmentsDir, `${answerRemoveId}.txt`)));
1463	assert.isFalse(yield* exists(removePath));	1512	assert.isFalse(yield* exists(removePath));
1464	assert.isTrue(yield* exists(laterPath));	1513	assert.isTrue(yield* exists(laterPath));
1465	assert.isTrue(yield* exists(otherThreadPath));	1514	assert.isTrue(yield* exists(otherThreadPath));
		1515
		1516	// Replay message and activity history from different cursors, as during a projection rebuild.
		1517	yield* sql`DELETE FROM projection_thread_messages WHERE thread_id = ${threadId}`;
		1518	yield* sql`DELETE FROM projection_thread_activities WHERE thread_id = ${threadId}`;
		1519	yield* sql`UPDATE projection_state SET last_applied_sequence = 0
		1520	WHERE projector IN ('projection.thread-messages', 'projection.thread-activities', 'projection.threads')`;
		1521	yield* fileSystem.writeFileString(removePath, "remove");
		1522	yield* fileSystem.writeFileString(
		1523	path.join(attachmentsDir, `${answerRemoveId}.txt`),
		1524	"answer",
		1525	);
		1526	yield* sql`CREATE TRIGGER fail_bootstrap_thread BEFORE UPDATE ON projection_threads
		1527	BEGIN SELECT RAISE(FAIL, 'forced bootstrap failure'); END`;
		1528	yield* projectionPipeline.bootstrap.pipe(Effect.flip);
		1529	assert.isTrue(yield* exists(removePath));
		1530	yield* sql`DROP TRIGGER fail_bootstrap_thread`;
		1531	yield* projectionPipeline.bootstrap;
		1532	assert.isTrue(yield* exists(keepPath));
		1533	assert.isTrue(yield* exists(laterPath));
		1534	assert.isTrue(yield* exists(path.join(attachmentsDir, `${answerKeepId}.txt`)));
		1535	assert.isFalse(yield* exists(removePath));
		1536	assert.isFalse(yield* exists(path.join(attachmentsDir, `${answerRemoveId}.txt`)));
1466	}),	1537	}),
1467	);	1538	);
1468	});	1539	});
...	@@ -1934,6 +2005,15 @@ it.layer(BaseTestLayer)("OrchestrationProjectionPipeline", (it) => {	...	@@ -1934,6 +2005,15 @@ it.layer(BaseTestLayer)("OrchestrationProjectionPipeline", (it) => {
1934	},	2005	},
1935	});	2006	});
1936		2007
		2008	yield* sql`CREATE TRIGGER fail_later_stream_projector BEFORE UPDATE ON projection_state
		2009	WHEN NEW.projector = 'projection.threads'
		2010	BEGIN SELECT RAISE(FAIL, 'forced later projector failure'); END`;
		2011	yield* projectionPipeline.bootstrap.pipe(Effect.flip);
		2012	const committedMessage = yield* sql<{ readonly text: string }>`
		2013	SELECT text FROM projection_thread_messages WHERE message_id = 'message-a'
		2014	`;
		2015	assert.deepEqual(committedMessage, [{ text: "hello world" }]);
		2016	yield* sql`DROP TRIGGER fail_later_stream_projector`;
1937	yield* projectionPipeline.bootstrap;	2017	yield* projectionPipeline.bootstrap;
1938	yield* projectionPipeline.bootstrap;	2018	yield* projectionPipeline.bootstrap;
1939		2019
...	@@ -3884,7 +3964,7 @@ const engineLayer = it.layer(	...	@@ -3884,7 +3964,7 @@ const engineLayer = it.layer(
3884	Layer.provideMerge(OrchestrationProjectionSnapshotQueryLive),	3964	Layer.provideMerge(OrchestrationProjectionSnapshotQueryLive),
3885	Layer.provide(ThreadBackgroundLiveness.layer),	3965	Layer.provide(ThreadBackgroundLiveness.layer),
3886	Layer.provide(ThreadPlanProgress.layer),	3966	Layer.provide(ThreadPlanProgress.layer),
3887	Layer.provide(OrchestrationProjectionPipelineLive),	3967	Layer.provideMerge(OrchestrationProjectionPipelineLive),
3888	Layer.provide(OrchestrationEventStoreLive),	3968	Layer.provide(OrchestrationEventStoreLive),
3889	Layer.provide(OrchestrationCommandReceiptRepositoryLive),	3969	Layer.provide(OrchestrationCommandReceiptRepositoryLive),
3890	Layer.provide(RepositoryIdentityResolver.layer),	3970	Layer.provide(RepositoryIdentityResolver.layer),
...	@@ -4236,7 +4316,10 @@ engineLayer("OrchestrationProjectionPipeline via engine dispatch", (it) => {	...	@@ -4236,7 +4316,10 @@ engineLayer("OrchestrationProjectionPipeline via engine dispatch", (it) => {
4236	yield* readCursors,	4316	yield* readCursors,
4237	cursorsBeforeFailure.map((cursor) => ({	4317	cursorsBeforeFailure.map((cursor) => ({
4238	...cursor,	4318	...cursor,
4239	lastAppliedSequence: result.sequence,	4319	lastAppliedSequence:
		4320	cursor.projector === "projection.attachment-cleanup"
		4321	? cursor.lastAppliedSequence
		4322	: result.sequence,
4240	})),	4323	})),
4241	);	4324	);
4242	assert.isFalse(yield* exists(attachmentPath));	4325	assert.isFalse(yield* exists(attachmentPath));
...	@@ -4266,6 +4349,25 @@ engineLayer("OrchestrationProjectionPipeline via engine dispatch", (it) => {	...	@@ -4266,6 +4349,25 @@ engineLayer("OrchestrationProjectionPipeline via engine dispatch", (it) => {
4266	WHERE command_id = ${cleanupFailureCommandId}	4349	WHERE command_id = ${cleanupFailureCommandId}
4267	`;	4350	`;
4268	assert.deepEqual(cleanupFailureReceipts, [{ status: "accepted" }]);	4351	assert.deepEqual(cleanupFailureReceipts, [{ status: "accepted" }]);
		4352
		4353	const pipeline = yield* OrchestrationProjectionPipeline;
		4354	const cleanupCursor = sql<{ readonly lastAppliedSequence: number }>`
		4355	SELECT last_applied_sequence AS "lastAppliedSequence" FROM projection_state
		4356	WHERE projector = 'projection.attachment-cleanup'
		4357	`;
		4358	const cursorBeforeRetry = yield* cleanupCursor;
		4359	yield* pipeline.bootstrap;
		4360	assert.deepEqual(yield* cleanupCursor, cursorBeforeRetry);
		4361	assert.isTrue(yield* exists(blockedAttachmentPath));
		4362
		4363	yield* fileSystem.remove(blockedAttachmentPath, { recursive: true });
		4364	yield* fileSystem.writeFileString(blockedAttachmentPath, "retry this attachment");
		4365	yield* pipeline.bootstrap;
		4366	assert.isFalse(yield* exists(blockedAttachmentPath));
		4367	assert.isAbove(
		4368	(yield* cleanupCursor)[0]!.lastAppliedSequence,
		4369	cursorBeforeRetry[0]!.lastAppliedSequence,
		4370	);
4269	}),	4371	}),
4270	);	4372	);
4271	});	4373	});

apps/server/src/orchestration/Layers/ProjectionPipeline.ts+89-31

 @@ -1,6 +1,7 @@
 import {
   ApprovalRequestId,
   isImportedAgentSessionMessageId,
+  UserInputAttachmentAnswerPayload,
   type ChatAttachment,
   type OrchestrationEvent,
   type OrchestrationSessionStatus,
 @@ -12,6 +13,7 @@ import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
 import * as Stream from "effect/Stream";
 import * as SqlClient from "effect/unstable/sql/SqlClient";
 @@ -327,6 +329,8 @@ function retainProjectionProposedPlansAfterRevert(
   );
 }
+const decodeQuestionAttachmentAnswer = Schema.decodeUnknownOption(UserInputAttachmentAnswerPayload);
 function collectThreadAttachmentRelativePaths(
   threadId: string,
   messages: ReadonlyArray<ProjectionThreadMessage>,
 @@ -359,9 +363,9 @@ const runAttachmentSideEffects = Effect.fn("runAttachmentSideEffects")(function*
   const path = yield* Effect.service(Path.Path);
   const attachmentsRootDir = serverConfig.attachmentsDir;
-  const readAttachmentRootEntries = fileSystem
+  const readAttachmentRootEntries = fileSystem.readDirectory(attachmentsRootDir, {
-    .readDirectory(attachmentsRootDir, { recursive: false })
+    recursive: false,
-    .pipe(Effect.orElseSucceed(() => [] as Array<string>));
+  });
   const removeDeletedThreadAttachmentEntry = Effect.fn("removeDeletedThreadAttachmentEntry")(
     function* (threadSegment: string, entry: string) {
 @@ -423,7 +427,7 @@ const runAttachmentSideEffects = Effect.fn("runAttachmentSideEffects")(function*
     }
     const absolutePath = path.join(attachmentsRootDir, relativePath);
-    const fileInfo = yield* fileSystem.stat(absolutePath).pipe(Effect.orElseSucceed(() => null));
+    const fileInfo = yield* fileSystem.stat(absolutePath);
     if (!fileInfo || fileInfo.type !== "File") {
       return;
     }
 @@ -1156,7 +1160,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
     const applyThreadActivitiesProjection: ProjectorDefinition["apply"] = Effect.fn(
       "applyThreadActivitiesProjection",
-    )(function* (event, _attachmentSideEffects) {
+    )(function* (event, attachmentSideEffects) {
       switch (event.type) {
         case "thread.created":
           yield* projectionThreadActivityRepository.deleteByThreadId({
 @@ -1204,6 +1208,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
           yield* Effect.forEach(keptRows, projectionThreadActivityRepository.upsert, {
             concurrency: 1,
           }).pipe(Effect.asVoid);
+          attachmentSideEffects.prunedThreadRelativePaths.set(event.payload.threadId, new Set());
           return;
         }
 @@ -1866,10 +1871,20 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
           const messages = yield* projectionThreadMessageRepository.listByThreadId({
             threadId: ThreadId.make(threadId),
           });
-          prunedThreadRelativePaths.set(
+          const retainedPaths = collectThreadAttachmentRelativePaths(threadId, messages);
-            threadId,
+          const activities = yield* projectionThreadActivityRepository.listByThreadId({
-            collectThreadAttachmentRelativePaths(threadId, messages),
+            threadId: ThreadId.make(threadId),
-          );
+          });
+          for (const activity of activities) {
+            if (activity.kind !== "user-input.answer-submitted") continue;
+            const payload = decodeQuestionAttachmentAnswer(activity.payload);
+            if (Option.isNone(payload)) continue;
+            for (const attachment of Object.values(payload.value.attachmentsByQuestionId).flat()) {
+              const relativePath = attachmentRelativePath(attachment);
+              if (relativePath) retainedPaths.add(relativePath);
+            }
+          }
+          prunedThreadRelativePaths.set(threadId, retainedPaths);
         }
         yield* runAttachmentSideEffects({ deletedThreadIds, prunedThreadRelativePaths });
 @@ -1879,29 +1894,17 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
       Effect.provideService(ServerConfig, serverConfig),
       (effect, event) =>
         effect.pipe(
+          Effect.as(true),
           Effect.catch((cause) =>
             Effect.logWarning("failed to apply projected attachment side-effects", {
               sequence: event.sequence,
               eventType: event.type,
               cause,
-            }),
+            }).pipe(Effect.as(false)),
           ),
         ),
     );
-    const applyProjectorForEvent = Effect.fn("applyProjectorForEvent")(function* (
-      projector: ProjectorDefinition,
-      event: OrchestrationEvent,
-      attachmentSideEffects: AttachmentSideEffects,
-    ) {
-      yield* projector.apply(event, attachmentSideEffects);
-      yield* projectionStateRepository.upsert({
-        projector: projector.name,
-        lastAppliedSequence: event.sequence,
-        updatedAt: event.occurredAt,
-      });
-    });
     const runProjectorForEvent = Effect.fn("runProjectorForEvent")(function* (
       projector: ProjectorDefinition,
       event: OrchestrationEvent,
 @@ -1911,8 +1914,16 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
         prunedThreadRelativePaths: new Map<string, Set<string>>(),
       };
-      yield* sql.withTransaction(applyProjectorForEvent(projector, event, attachmentSideEffects));
+      yield* sql.withTransaction(
-      yield* applyAttachmentSideEffects(event, attachmentSideEffects);
+        Effect.gen(function* () {
+          yield* projector.apply(event, attachmentSideEffects);
+          yield* projectionStateRepository.upsert({
+            projector: projector.name,
+            lastAppliedSequence: event.sequence,
+            updatedAt: event.occurredAt,
+          });
+        }),
+      );
     });
     const bootstrapProjector = (projector: ProjectorDefinition) =>
 @@ -1958,7 +1969,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
           );
           // Return the cleanup effect so the caller runs it after the outer transaction commits.
           // @effect-diagnostics-next-line returnEffectInGen:off
-          return applyAttachmentSideEffects(event, attachmentSideEffects);
+          return applyAttachmentSideEffects(event, attachmentSideEffects).pipe(Effect.asVoid);
         },
         Effect.provideService(FileSystem.FileSystem, fileSystem),
         Effect.provideService(Path.Path, path),
 @@ -1975,11 +1986,58 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
       yield* cleanup;
     });
-    const bootstrap: OrchestrationProjectionPipelineShape["bootstrap"] = Effect.forEach(
+    const bootstrap: OrchestrationProjectionPipelineShape["bootstrap"] = Effect.gen(function* () {
-      projectors,
+      const cleanupProjector = "projection.attachment-cleanup";
-      bootstrapProjector,
+      const states = yield* projectionStateRepository.listAll();
-      { concurrency: 1 },
+      const byProjector = new Map(states.map((state) => [state.projector, state]));
-    ).pipe(
+      const cleanupState = byProjector.get(cleanupProjector);
+      const cleanupStart = Math.min(
+        cleanupState?.lastAppliedSequence ?? 0,
+        ...projectors.map((projector) => byProjector.get(projector.name)?.lastAppliedSequence ?? 0),
+      );
+      // Persist this boundary before replay: a reset projector can encounter an old
+      // revert, then fail after other projectors have committed past that event.
+      yield* projectionStateRepository.upsert({
+        projector: cleanupProjector,
+        lastAppliedSequence: cleanupStart,
+        updatedAt: cleanupState?.updatedAt ?? "1970-01-01T00:00:00.000Z",
+      });
+      yield* Effect.forEach(projectors, bootstrapProjector, { concurrency: 1, discard: true });
+      // Cleanup has its own cursor so retries never have to replay committed text.
+      // All message and activity references are current before any files are removed.
+      const pendingCleanup = new Map<string, OrchestrationEvent>();
+      let lastEvent: OrchestrationEvent | undefined;
+      yield* Stream.runForEach(
+        eventStore.readFromSequence(cleanupStart, Number.MAX_SAFE_INTEGER),
+        (event) =>
+          Effect.sync(() => {
+            lastEvent = event;
+            if (event.type === "thread.reverted" || event.type === "thread.deleted") {
+              pendingCleanup.set(`${event.type}:${event.payload.threadId}`, event);
+            }
+          }),
+      );
+      for (const event of pendingCleanup.values()) {
+        if (event.type !== "thread.reverted" && event.type !== "thread.deleted") continue;
+        const threadId = event.payload.threadId;
+        const cleaned = yield* applyAttachmentSideEffects(event, {
+          deletedThreadIds: new Set(event.type === "thread.deleted" ? [threadId] : []),
+          prunedThreadRelativePaths: new Map(
+            event.type === "thread.reverted" ? [[threadId, new Set<string>()]] : [],
+          ),
+        });
+        // Leave the cleanup cursor behind this event so the next bootstrap retries it.
+        if (!cleaned) return;
+      }
+      if (lastEvent) {
+        yield* projectionStateRepository.upsert({
+          projector: cleanupProjector,
+          lastAppliedSequence: lastEvent.sequence,
+          updatedAt: lastEvent.occurredAt,
+        });
+      }
+    }).pipe(
       Effect.provideService(FileSystem.FileSystem, fileSystem),
       Effect.provideService(Path.Path, path),
       Effect.provideService(ServerConfig, serverConfig),

apps/server/src/orchestration/Layers/ProviderCommandReactor.ts+3

 @@ -1609,6 +1609,9 @@ const make = Effect.gen(function* () {
           threadId: event.payload.threadId,
           requestId: event.payload.requestId,
           answers: event.payload.answers,
+          ...(event.payload.attachmentsByQuestionId
+            ? { attachmentsByQuestionId: event.payload.attachmentsByQuestionId }
+            : {}),
         })
         .pipe(
           Effect.catchCause((cause) =>

apps/server/src/orchestration/Normalizer.attachments.test.ts+202-1

...	@@ -5,13 +5,15 @@ import * as NodePath from "node:path";	...	@@ -5,13 +5,15 @@ import * as NodePath from "node:path";
5	import * as NodeServices from "@effect/platform-node/NodeServices";	5	import * as NodeServices from "@effect/platform-node/NodeServices";
6	import { describe, expect, it } from "@effect/vitest";	6	import { describe, expect, it } from "@effect/vitest";
7	import {	7	import {
8	type ClientOrchestrationCommand,	8	ClientOrchestrationCommand,
9	CommandId,	9	CommandId,
		10	ApprovalRequestId,
10	MessageId,	11	MessageId,
11	ThreadId,	12	ThreadId,
12	} from "@t3tools/contracts";	13	} from "@t3tools/contracts";
13	import * as Effect from "effect/Effect";	14	import * as Effect from "effect/Effect";
14	import * as Layer from "effect/Layer";	15	import * as Layer from "effect/Layer";
		16	import * as Schema from "effect/Schema";
15		17
16	import * as ServerConfig from "../config.ts";	18	import * as ServerConfig from "../config.ts";
17	import * as WorkspacePaths from "../workspace/WorkspacePaths.ts";	19	import * as WorkspacePaths from "../workspace/WorkspacePaths.ts";
...	@@ -23,6 +25,7 @@ const testLayer = Layer.mergeAll(	...	@@ -23,6 +25,7 @@ const testLayer = Layer.mergeAll(
23	).pipe(Layer.provideMerge(NodeServices.layer));	25	).pipe(Layer.provideMerge(NodeServices.layer));
24		26
25	const attachmentUuid = "00000000-0000-4000-8000-0000000000aa";	27	const attachmentUuid = "00000000-0000-4000-8000-0000000000aa";
		28	const isClientCommand = Schema.is(ClientOrchestrationCommand);
26		29
27	function turnStartCommand(input: {	30	function turnStartCommand(input: {
28	readonly threadId?: string;	31	readonly threadId?: string;
...	@@ -358,3 +361,201 @@ describe("normalizeDispatchCommand attachments", () => {	...	@@ -358,3 +361,201 @@ describe("normalizeDispatchCommand attachments", () => {
358	}).pipe(Effect.provide(testLayer)),	361	}).pipe(Effect.provide(testLayer)),
359	);	362	);
360	});	363	});
		364
		365	describe("question attachments", () => {
		366	it.effect("enforces the total response limit and claims duplicate filenames independently", () =>
		367	Effect.gen(function* () {
		368	const config = yield* ServerConfig.ServerConfig;
		369	const id = `pending-${attachmentUuid}-txt`;
		370	NodeFS.writeFileSync(NodePath.join(config.attachmentsDir, `${id}.txt`), "report");
		371	const attachment = {
		372	type: "file" as const,
		373	id,
		374	name: 'notes "final" ü.txt',
		375	mimeType: "text/plain",
		376	sizeBytes: 6,
		377	};
		378	const command: ClientOrchestrationCommand = {
		379	type: "thread.user-input.respond",
		380	commandId: CommandId.make("answer-cap"),
		381	threadId: ThreadId.make("thread-1"),
		382	requestId: ApprovalRequestId.make("request-cap"),
		383	answers: { first: "", second: "" },
		384	createdAt: "2026-08-01T00:00:00.000Z",
		385	attachmentsByQuestionId: {
		386	first: Array.from({ length: 4 }, () => attachment),
		387	second: Array.from({ length: 5 }, () => attachment),
		388	},
		389	};
		390	const failure = yield* normalizeDispatchCommand(command).pipe(Effect.flip);
		391	expect(failure.message).toContain("up to 8");
		392	expect(NodeFS.readdirSync(config.attachmentsDir)).toEqual([`${id}.txt`]);
		393	const accepted = {
		394	...command,
		395	attachmentsByQuestionId: {
		396	...command.attachmentsByQuestionId,
		397	second: Array.from({ length: 4 }, () => attachment),
		398	},
		399	};
		400	const normalized = yield* normalizeDispatchCommand(accepted);
		401	if (normalized.type !== "thread.user-input.respond") throw new Error("Wrong command");
		402	const attachments = Object.values(normalized.attachmentsByQuestionId!).flat();
		403	expect(attachments).toHaveLength(8);
		404	expect(new Set(attachments.map((item) => item.id)).size).toBe(8);
		405	for (const item of attachments) {
		406	expect(item.name).toBe(attachment.name);
		407	expect(
		408	NodeFS.readFileSync(NodePath.join(config.attachmentsDir, `${item.id}.txt`), "utf8"),
		409	).toBe("report");
		410	}
		411	yield* cleanupFailedUploadedAttachments(accepted, normalized);
		412	expect(NodeFS.readdirSync(config.attachmentsDir)).toEqual([`${id}.txt`]);
		413	}).pipe(Effect.provide(testLayer)),
		414	);
		415	it("requires uploaded metadata for question images, including pasted images", () => {
		416	expect(
		417	isClientCommand({
		418	type: "thread.user-input.respond",
		419	commandId: "answer",
		420	threadId: "thread-1",
		421	requestId: "request",
		422	answers: { q: "" },
		423	createdAt: "2026-08-01T00:00:00.000Z",
		424	attachmentsByQuestionId: {
		425	q: [
		426	{
		427	type: "image",
		428	name: "image.png",
		429	mimeType: "image/png",
		430	sizeBytes: 6,
		431	dataUrl: "data:image/png;base64,cGl4ZWxz",
		432	},
		433	],
		434	},
		435	}),
		436	).toBe(false);
		437	});
		438
		439	it.effect("preserves a __proto__ question key and cleans up its claimed files", () =>
		440	Effect.gen(function* () {
		441	const config = yield* ServerConfig.ServerConfig;
		442	const id = `pending-${attachmentUuid}`;
		443	NodeFS.writeFileSync(NodePath.join(config.attachmentsDir, `${id}.png`), "pixels");
		444	const command: ClientOrchestrationCommand = {
		445	type: "thread.user-input.respond",
		446	commandId: CommandId.make("answer"),
		447	threadId: ThreadId.make("thread-1"),
		448	requestId: ApprovalRequestId.make("request"),
		449	answers: { ["__proto__"]: "" },
		450	createdAt: "2026-08-01T00:00:00.000Z",
		451	attachmentsByQuestionId: {
		452	["__proto__"]: [
		453	{ type: "image", id, name: "image.png", mimeType: "image/png", sizeBytes: 6 },
		454	],
		455	},
		456	};
		457	const normalized = yield* normalizeDispatchCommand(command);
		458	if (normalized.type !== "thread.user-input.respond") throw new Error("Wrong command");
		459	expect(Object.keys(normalized.attachmentsByQuestionId!)).toEqual(["__proto__"]);
		460	const attachment = normalized.attachmentsByQuestionId!["__proto__"]![0]!;
		461	const claimedPath = NodePath.join(config.attachmentsDir, `${attachment.id}.png`);
		462	expect(NodeFS.existsSync(claimedPath)).toBe(true);
		463	yield* cleanupFailedUploadedAttachments(command, normalized);
		464	expect(NodeFS.existsSync(claimedPath)).toBe(false);
		465	}).pipe(Effect.provide(testLayer)),
		466	);
		467	it.effect(
		468	"claims images and files by question, preserves answers, and cleans up failed dispatches",
		469	() =>
		470	Effect.gen(function* () {
		471	const config = yield* ServerConfig.ServerConfig;
		472	const imageId = `pending-${attachmentUuid}`;
		473	const fileId = `pending-${attachmentUuid}-txt`;
		474	NodeFS.writeFileSync(NodePath.join(config.attachmentsDir, `${imageId}.png`), "pixels");
		475	NodeFS.writeFileSync(NodePath.join(config.attachmentsDir, `${fileId}.txt`), "report");
		476	const command: ClientOrchestrationCommand = {
		477	type: "thread.user-input.respond",
		478	commandId: CommandId.make("answer"),
		479	threadId: ThreadId.make("thread-1"),
		480	requestId: ApprovalRequestId.make("request"),
		481	answers: { q1: ["Selected option"], q2: "" },
		482	createdAt: "2026-08-01T00:00:00.000Z",
		483	attachmentsByQuestionId: {
		484	q1: [
		485	{
		486	type: "image",
		487	id: imageId,
		488	name: "image.png",
		489	mimeType: "image/png",
		490	sizeBytes: 6,
		491	},
		492	],
		493	q2: [
		494	{
		495	type: "file",
		496	id: fileId,
		497	name: "report.txt",
		498	mimeType: "text/plain",
		499	sizeBytes: 6,
		500	},
		501	],
		502	},
		503	};
		504	const normalized = yield* normalizeDispatchCommand(command);
		505	if (normalized.type !== "thread.user-input.respond") throw new Error("Wrong command");
		506	expect(normalized.answers).toEqual(command.answers);
		507	const image = normalized.attachmentsByQuestionId!.q1![0]!;
		508	const file = normalized.attachmentsByQuestionId!.q2![0]!;
		509	expect(
		510	NodeFS.readFileSync(NodePath.join(config.attachmentsDir, `${image.id}.png`), "utf8"),
		511	).toBe("pixels");
		512	expect(
		513	NodeFS.readFileSync(NodePath.join(config.attachmentsDir, `${file.id}.txt`), "utf8"),
		514	).toBe("report");
		515	yield* cleanupFailedUploadedAttachments(command, normalized);
		516	expect(NodeFS.existsSync(NodePath.join(config.attachmentsDir, `${image.id}.png`))).toBe(
		517	false,
		518	);
		519	expect(NodeFS.existsSync(NodePath.join(config.attachmentsDir, `${file.id}.txt`))).toBe(
		520	false,
		521	);
		522	expect(NodeFS.existsSync(NodePath.join(config.attachmentsDir, `${imageId}.png`))).toBe(
		523	true,
		524	);
		525	const retry = yield* normalizeDispatchCommand(command);
		526	expect(retry.type).toBe("thread.user-input.respond");
		527	}).pipe(Effect.provide(testLayer)),
		528	);
		529
		530	it.effect("removes all claimed copies if a later question upload is missing", () =>
		531	Effect.gen(function* () {
		532	const config = yield* ServerConfig.ServerConfig;
		533	const id = `pending-${attachmentUuid}`;
		534	NodeFS.writeFileSync(NodePath.join(config.attachmentsDir, `${id}.png`), "pixels");
		535	const result = yield* normalizeDispatchCommand({
		536	type: "thread.user-input.respond",
		537	commandId: CommandId.make("answer"),
		538	threadId: ThreadId.make("thread-1"),
		539	requestId: ApprovalRequestId.make("request"),
		540	answers: { q1: "", q2: "" },
		541	createdAt: "2026-08-01T00:00:00.000Z",
		542	attachmentsByQuestionId: {
		543	q1: [{ type: "image", id, name: "image.png", mimeType: "image/png", sizeBytes: 6 }],
		544	q2: [
		545	{
		546	type: "file",
		547	id: `${id}-txt`,
		548	name: "missing.txt",
		549	mimeType: "text/plain",
		550	sizeBytes: 6,
		551	},
		552	],
		553	},
		554	}).pipe(Effect.result);
		555	expect(result._tag).toBe("Failure");
		556	expect(
		557	NodeFS.readdirSync(config.attachmentsDir).filter((name) => name.startsWith("thread-1-")),
		558	).toEqual([]);
		559	}).pipe(Effect.provide(testLayer)),
		560	);
		561	});

apps/server/src/orchestration/Normalizer.ts+53-7

...	@@ -4,6 +4,8 @@ import * as FileSystem from "effect/FileSystem";	...	@@ -4,6 +4,8 @@ import * as FileSystem from "effect/FileSystem";
4	import * as Path from "effect/Path";	4	import * as Path from "effect/Path";
5	import {	5	import {
6	type ClientOrchestrationCommand,	6	type ClientOrchestrationCommand,
		7	type UserInputAttachments,
		8	PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
7	type IsoDateTime,	9	type IsoDateTime,
8	type OrchestrationCommand,	10	type OrchestrationCommand,
9	OrchestrationDispatchCommandError,	11	OrchestrationDispatchCommandError,
...	@@ -129,13 +131,28 @@ export const normalizeDispatchCommand = (command: ClientOrchestrationCommand) =>	...	@@ -129,13 +131,28 @@ export const normalizeDispatchCommand = (command: ClientOrchestrationCommand) =>
129	} satisfies OrchestrationCommand;	131	} satisfies OrchestrationCommand;
130	}	132	}
131		133
132	if (canonicalCommand.type !== "thread.turn.start") {	134	if (
		135	canonicalCommand.type !== "thread.turn.start" &&
		136	canonicalCommand.type !== "thread.user-input.respond"
		137	) {
133	return canonicalCommand as OrchestrationCommand;	138	return canonicalCommand as OrchestrationCommand;
134	}	139	}
135		140
		141	const attachments =
		142	canonicalCommand.type === "thread.turn.start"
		143	? canonicalCommand.message.attachments
		144	: Object.values(canonicalCommand.attachmentsByQuestionId ?? {}).flat();
		145	if (
		146	canonicalCommand.type === "thread.user-input.respond" &&
		147	attachments.length > PROVIDER_SEND_TURN_MAX_ATTACHMENTS
		148	) {
		149	return yield* new OrchestrationDispatchCommandError({
		150	message: `You can attach up to ${PROVIDER_SEND_TURN_MAX_ATTACHMENTS} files per question response.`,
		151	});
		152	}
136	const claimedAttachmentPaths: string[] = [];	153	const claimedAttachmentPaths: string[] = [];
137	const normalizedAttachments = yield* Effect.forEach(	154	const normalizedAttachments = yield* Effect.forEach(
138	canonicalCommand.message.attachments,	155	attachments,
139	(attachment) =>	156	(attachment) =>
140	Effect.gen(function* () {	157	Effect.gen(function* () {
141	if (!("dataUrl" in attachment)) {	158	if (!("dataUrl" in attachment)) {
...	@@ -260,6 +277,25 @@ export const normalizeDispatchCommand = (command: ClientOrchestrationCommand) =>	...	@@ -260,6 +277,25 @@ export const normalizeDispatchCommand = (command: ClientOrchestrationCommand) =>
260	{ concurrency: 1 },	277	{ concurrency: 1 },
261	).pipe(Effect.tapError(() => removeClaimedAttachmentPaths(claimedAttachmentPaths)));	278	).pipe(Effect.tapError(() => removeClaimedAttachmentPaths(claimedAttachmentPaths)));
262		279
		280	if (canonicalCommand.type === "thread.user-input.respond") {
		281	let index = 0;
		282	const attachmentsByQuestionId = Object.fromEntries(
		283	Object.entries(canonicalCommand.attachmentsByQuestionId ?? {}).map(
		284	([questionId, original]) => {
		285	const claimed = normalizedAttachments.slice(
		286	index,
		287	index + original.length,
		288	) as UserInputAttachments[string];
		289	index += original.length;
		290	return [questionId, claimed];
		291	},
		292	),
		293	);
		294	return {
		295	...canonicalCommand,
		296	...(attachments.length > 0 ? { attachmentsByQuestionId } : {}),
		297	};
		298	}
263	return {	299	return {
264	...canonicalCommand,	300	...canonicalCommand,
265	message: {	301	message: {
...	@@ -272,14 +308,24 @@ export const normalizeDispatchCommand = (command: ClientOrchestrationCommand) =>	...	@@ -272,14 +308,24 @@ export const normalizeDispatchCommand = (command: ClientOrchestrationCommand) =>
272	export const cleanupFailedUploadedAttachments = Effect.fn(	308	export const cleanupFailedUploadedAttachments = Effect.fn(
273	"Normalizer.cleanupFailedUploadedAttachments",	309	"Normalizer.cleanupFailedUploadedAttachments",
274	)(function* (command: ClientOrchestrationCommand, normalizedCommand: OrchestrationCommand) {	310	)(function* (command: ClientOrchestrationCommand, normalizedCommand: OrchestrationCommand) {
275	if (command.type !== "thread.turn.start" \|\| normalizedCommand.type !== "thread.turn.start") {	311	const originalAttachments =
276	return;	312	command.type === "thread.turn.start"
277	}	313	? command.message.attachments
		314	: command.type === "thread.user-input.respond"
		315	? Object.values(command.attachmentsByQuestionId ?? {}).flat()
		316	: [];
		317	const normalizedAttachments =
		318	normalizedCommand.type === "thread.turn.start"
		319	? normalizedCommand.message.attachments
		320	: normalizedCommand.type === "thread.user-input.respond"
		321	? Object.values(normalizedCommand.attachmentsByQuestionId ?? {}).flat()
		322	: [];
		323	if (normalizedAttachments.length === 0) return;
278		324
279	const serverConfig = yield* ServerConfig;	325	const serverConfig = yield* ServerConfig;
280	const claimedPaths: string[] = [];	326	const claimedPaths: string[] = [];
281	for (const [index, attachment] of normalizedCommand.message.attachments.entries()) {	327	for (const [index, attachment] of normalizedAttachments.entries()) {
282	const original = command.message.attachments[index];	328	const original = originalAttachments[index];
283	if (	329	if (
284	!original \|\|	330	!original \|\|
285	"dataUrl" in original \|\|	331	"dataUrl" in original \|\|

apps/server/src/orchestration/decider.questionAttachments.test.ts created+130

...	@@ -0,0 +1,130 @@
1	import {
2	ApprovalRequestId,
3	EventId,
4	CommandId,
5	ProjectId,
6	ProviderInstanceId,
7	ThreadId,
8	type OrchestrationReadModel,
9	} from "@t3tools/contracts";
10	import * as NodeServices from "@effect/platform-node/NodeServices";
11	import { expect, it } from "@effect/vitest";
12	import * as Effect from "effect/Effect";
13
14	import { decideOrchestrationCommand } from "./decider.ts";
15
16	const UPDATED_AT = "2026-01-01T00:00:00.000Z";
17
18	const readModel: OrchestrationReadModel = {
19	snapshotSequence: 0,
20	projects: [],
21	threads: [
22	{
23	id: ThreadId.make("thread-1"),
24	projectId: ProjectId.make("project-1"),
25	title: "Manual title",
26	modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
27	runtimeMode: "full-access",
28	interactionMode: "default",
29	branch: null,
30	worktreePath: null,
31	latestTurn: null,
32	createdAt: UPDATED_AT,
33	updatedAt: UPDATED_AT,
34	archivedAt: null,
35	settledOverride: null,
36	settledAt: null,
37	snoozedUntil: null,
38	snoozedAt: null,
39	deletedAt: null,
40	messages: [],
41	proposedPlans: [],
42	activities: [],
43	checkpoints: [],
44	session: null,
45	},
46	],
47	updatedAt: UPDATED_AT,
48	};
49
50	const requestId = ApprovalRequestId.make("question-request");
51	const command = {
52	type: "thread.user-input.respond" as const,
53	commandId: CommandId.make("answer"),
54	threadId: ThreadId.make("thread-1"),
55	requestId,
56	answers: { q: "" },
57	createdAt: UPDATED_AT,
58	attachmentsByQuestionId: {
59	q: [
60	{
61	type: "file" as const,
62	id: "thread-1-00000000-0000-4000-8000-0000000000aa-txt",
63	name: "spec.txt",
64	mimeType: "text/plain",
65	sizeBytes: 4,
66	},
67	],
68	},
69	};
70	const request = {
71	id: EventId.make("question"),
72	kind: "user-input.requested",
73	summary: "Question",
74	tone: "info" as const,
75	turnId: null,
76	createdAt: UPDATED_AT,
77	payload: {
78	requestId,
79	questions: [
80	{ id: "q", header: "Spec", question: "Provide a spec", options: [], allowCustomAnswer: true },
81	],
82	},
83	};
84	it.layer(NodeServices.layer)("question attachment answers", (it) => {
85	it.effect("persists the original answer with its attachment and emits a provider response", () =>
86	Effect.gen(function* () {
87	const result = yield* decideOrchestrationCommand({
88	readModel,
89	command,
90	userInputActivity: request,
91	});
92	const events = Array.isArray(result) ? result : [result];
93	expect(events.map((event) => event.type)).toEqual([
94	"thread.activity-appended",
95	"thread.user-input-response-requested",
96	]);
97	expect(events[0]?.payload).toMatchObject({
98	activity: {
99	kind: "user-input.answer-submitted",
100	payload: { answers: { q: "" }, attachmentsByQuestionId: command.attachmentsByQuestionId },
101	},
102	});
103	expect(events[1]?.payload).toMatchObject({
104	answers: { q: "" },
105	attachmentsByQuestionId: command.attachmentsByQuestionId,
106	});
107	}),
108	);
109	it.effect("rejects attachments for a resolved or unknown request", () =>
110	Effect.gen(function* () {
111	const result = yield* decideOrchestrationCommand({ readModel, command }).pipe(Effect.result);
112	expect(result._tag).toBe("Failure");
113	}),
114	);
115	it.effect("rejects unknown question IDs and predefined-choice-only protocols", () =>
116	Effect.gen(function* () {
117	for (const question of [
118	{ ...request.payload.questions[0], id: "other" },
119	{ ...request.payload.questions[0], allowCustomAnswer: false },
120	]) {
121	const result = yield* decideOrchestrationCommand({
122	readModel,
123	command,
124	userInputActivity: { ...request, payload: { ...request.payload, questions: [question] } },
125	}).pipe(Effect.result);
126	expect(result._tag).toBe("Failure");
127	}
128	}),
129	);
130	});

apps/server/src/orchestration/decider.ts+76-8

...	@@ -1222,6 +1222,35 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"	...	@@ -1222,6 +1222,35 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"
1222	threadId: command.threadId,	1222	threadId: command.threadId,
1223	});	1223	});
1224	const request = userInputActivity;	1224	const request = userInputActivity;
		1225	const attachments = Object.values(command.attachmentsByQuestionId ?? {}).flat();
		1226	let questionTextById: Record<string, string> = {};
		1227	if (attachments.length > 0) {
		1228	const payload =
		1229	request?.kind === "user-input.requested"
		1230	? decodeUserInputRequestedPayload(request.payload)
		1231	: Option.none();
		1232	if (Option.isNone(payload)) {
		1233	return yield* new OrchestrationCommandInvariantError({
		1234	commandType: command.type,
		1235	detail:
		1236	request?.kind === "user-input.resolved"
		1237	? "This question has already been answered."
		1238	: "This question is no longer pending.",
		1239	});
		1240	}
		1241	questionTextById = Object.fromEntries(
		1242	payload.value.questions.map((question) => [question.id, question.question]),
		1243	);
		1244	for (const questionId of Object.keys(command.attachmentsByQuestionId ?? {})) {
		1245	const question = payload.value.questions.find((question) => question.id === questionId);
		1246	if (!question \|\| question.allowCustomAnswer === false) {
		1247	return yield* new OrchestrationCommandInvariantError({
		1248	commandType: command.type,
		1249	detail: "This question does not accept file references.",
		1250	});
		1251	}
		1252	}
		1253	}
1225	if (	1254	if (
1226	request &&	1255	request &&
1227	Predicate.isObject(request.payload) &&	1256	Predicate.isObject(request.payload) &&
...	@@ -1237,13 +1266,22 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"	...	@@ -1237,13 +1266,22 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"
1237	const replies: string[] = [];	1266	const replies: string[] = [];
1238	for (const question of payload.value.questions) {	1267	for (const question of payload.value.questions) {
1239	const answer = command.answers[question.id];	1268	const answer = command.answers[question.id];
1240	if (typeof answer !== "string" \|\| answer.trim().length === 0) {	1269	if (
		1270	typeof answer !== "string" \|\|
		1271	(answer.trim().length === 0 && !command.attachmentsByQuestionId?.[question.id]?.length)
		1272	) {
1241	return yield* new OrchestrationCommandInvariantError({	1273	return yield* new OrchestrationCommandInvariantError({
1242	commandType: command.type,	1274	commandType: command.type,
1243	detail: "Answer each question before sending.",	1275	detail: "Answer each question before sending.",
1244	});	1276	});
1245	}	1277	}
1246	replies.push(`${question.question}\n${answer.trim()}`);	1278	const questionAttachments = command.attachmentsByQuestionId?.[question.id] ?? [];
		1279	const attachmentLabels = questionAttachments
		1280	.map((attachment) => `Attached file: ${attachment.name} (${attachment.id})`)
		1281	.join("\n");
		1282	replies.push(
		1283	[`${question.question}\n${answer.trim()}`, attachmentLabels].filter(Boolean).join("\n"),
		1284	);
1247	}	1285	}
1248	// Commit the answer and its message together. The normal turn path	1286	// Commit the answer and its message together. The normal turn path
1249	// steers a running agent or resumes an idle session.	1287	// steers a running agent or resumes an idle session.
...	@@ -1266,6 +1304,9 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"	...	@@ -1266,6 +1304,9 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"
1266	requestId: command.requestId,	1304	requestId: command.requestId,
1267	responseMode: "message",	1305	responseMode: "message",
1268	answers: command.answers,	1306	answers: command.answers,
		1307	...(command.attachmentsByQuestionId
		1308	? { attachmentsByQuestionId: command.attachmentsByQuestionId }
		1309	: {}),
1269	},	1310	},
1270	},	1311	},
1271	},	1312	},
...	@@ -1280,30 +1321,57 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"	...	@@ -1280,30 +1321,57 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"
1280	messageId: MessageId.make(`async-answer:${command.requestId}`),	1321	messageId: MessageId.make(`async-answer:${command.requestId}`),
1281	role: "user",	1322	role: "user",
1282	text: replies.join("\n\n"),	1323	text: replies.join("\n\n"),
1283	attachments: [],	1324	attachments,
1284	},	1325	},
1285	},	1326	},
1286	],	1327	],
1287	});	1328	});
1288	}	1329	}
1289	return {	1330	const responseEvent = {
1290	...(yield* withEventBase({	1331	...(yield* withEventBase({
1291	aggregateKind: "thread",	1332	aggregateKind: "thread",
1292	aggregateId: command.threadId,	1333	aggregateId: command.threadId,
1293	occurredAt: command.createdAt,	1334	occurredAt: command.createdAt,
1294	commandId: command.commandId,	1335	commandId: command.commandId,
1295	metadata: {	1336	metadata: { requestId: command.requestId },
1296	requestId: command.requestId,
1297	},
1298	})),	1337	})),
1299	type: "thread.user-input-response-requested",	1338	type: "thread.user-input-response-requested" as const,
1300	payload: {	1339	payload: {
1301	threadId: command.threadId,	1340	threadId: command.threadId,
1302	requestId: command.requestId,	1341	requestId: command.requestId,
1303	answers: command.answers,	1342	answers: command.answers,
		1343	...(command.attachmentsByQuestionId
		1344	? { attachmentsByQuestionId: command.attachmentsByQuestionId }
		1345	: {}),
1304	createdAt: command.createdAt,	1346	createdAt: command.createdAt,
1305	},	1347	},
1306	};	1348	};
		1349	if (attachments.length === 0) return responseEvent;
		1350	const historyEvent = yield* decideOrchestrationCommand({
		1351	readModel,
		1352	command: {
		1353	type: "thread.activity.append",
		1354	commandId: command.commandId,
		1355	threadId: command.threadId,
		1356	createdAt: command.createdAt,
		1357	activity: {
		1358	id: EventId.make(`question-answer:${command.commandId}`),
		1359	kind: "user-input.answer-submitted",
		1360	summary: "Question answer submitted",
		1361	tone: "info",
		1362	turnId: request?.turnId ?? null,
		1363	createdAt: command.createdAt,
		1364	payload: {
		1365	requestId: command.requestId,
		1366	answers: command.answers,
		1367	questionTextById,
		1368	attachmentsByQuestionId: command.attachmentsByQuestionId,
		1369	detail: attachments.map((attachment) => attachment.name).join("\n"),
		1370	},
		1371	},
		1372	},
		1373	});
		1374	return [...(Array.isArray(historyEvent) ? historyEvent : [historyEvent]), responseEvent];
1307	}	1375	}
1308		1376
1309	case "thread.user-input.dismiss": {	1377	case "thread.user-input.dismiss": {

apps/server/src/provider/Layers/ProviderService.ts+6-1

 @@ -49,6 +49,7 @@ import * as Schema from "effect/Schema";
 import * as SchemaIssue from "effect/SchemaIssue";
 import * as Stream from "effect/Stream";
+import { appendUserInputAttachmentPaths } from "../userInputAttachments.ts";
 import { resolveAttachmentPath } from "../../attachmentStore.ts";
 import * as ServerConfig from "../../config.ts";
 import {
 @@ -1919,7 +1920,11 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (
         "provider.thread_id": input.threadId,
         "provider.request_id": input.requestId,
       });
-      yield* routed.adapter.respondToUserInput(routed.threadId, input.requestId, input.answers);
+      const answers = yield* appendUserInputAttachmentPaths({
+        ...input,
+        attachmentsDir: serverConfig.attachmentsDir,
+      }).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem));
+      yield* routed.adapter.respondToUserInput(routed.threadId, input.requestId, answers);
     }).pipe(
       withMetrics({
         counter: providerTurnsTotal,

apps/server/src/provider/userInputAttachments.test.ts created+61

...	@@ -0,0 +1,61 @@
1	// @effect-diagnostics nodeBuiltinImport:off
2	import * as NodeFS from "node:fs";
3	import * as NodePath from "node:path";
4	import * as NodeServices from "@effect/platform-node/NodeServices";
5	import { describe, expect, it } from "@effect/vitest";
6	import * as Effect from "effect/Effect";
7	import * as Layer from "effect/Layer";
8	import * as ServerConfig from "../config.ts";
9	import { appendUserInputAttachmentPaths } from "./userInputAttachments.ts";
10
11	const layer = ServerConfig.layerTest(process.cwd(), { prefix: "t3-answer-paths-" }).pipe(
12	Layer.provideMerge(NodeServices.layer),
13	);
14	const attachment = {
15	type: "file" as const,
16	id: "thread-1-00000000-0000-4000-8000-0000000000aa-txt",
17	name: 'spec "final".txt',
18	mimeType: "text/plain",
19	sizeBytes: 4,
20	};
21	describe("question answer paths", () => {
22	it.effect("keeps selected values intact and appends an actual readable server path", () =>
23	Effect.gen(function* () {
24	const config = yield* ServerConfig.ServerConfig;
25	const path = NodePath.join(config.attachmentsDir, `${attachment.id}.txt`);
26	NodeFS.writeFileSync(path, "spec");
27	const original = { q: ["First", "Second"], other: "No file" };
28	const answers = yield* appendUserInputAttachmentPaths({
29	answers: original,
30	attachmentsDir: config.attachmentsDir,
31	attachmentsByQuestionId: { q: [attachment] },
32	});
33	expect(answers.q).toEqual([
34	"First",
35	"Second",
36	`Attached file "spec \\"final\\".txt": "${path}"`,
37	]);
38	expect(answers.other).toBe("No file");
39	expect(original.q).toEqual(["First", "Second"]);
40	expect(NodeFS.readFileSync(path, "utf8")).toBe("spec");
41	const specialKey = yield* appendUserInputAttachmentPaths({
42	answers: {},
43	attachmentsDir: config.attachmentsDir,
44	attachmentsByQuestionId: { ["__proto__"]: [attachment] },
45	});
46	expect(Object.keys(specialKey)).toEqual(["__proto__"]);
47	expect(specialKey["__proto__"]).toContain(path);
48	}).pipe(Effect.provide(layer)),
49	);
50	it.effect("does not send an unavailable attachment path", () =>
51	Effect.gen(function* () {
52	const config = yield* ServerConfig.ServerConfig;
53	const result = yield* appendUserInputAttachmentPaths({
54	answers: { q: "" },
55	attachmentsDir: config.attachmentsDir,
56	attachmentsByQuestionId: { q: [attachment] },
57	}).pipe(Effect.result);
58	expect(result._tag).toBe("Failure");
59	}).pipe(Effect.provide(layer)),
60	);
61	});

apps/server/src/provider/userInputAttachments.ts created+59

...	@@ -0,0 +1,59 @@
1	import type { ProviderUserInputAnswers, UserInputAttachments } from "@t3tools/contracts";
2	import * as Schema from "effect/Schema";
3	import * as Effect from "effect/Effect";
4	import * as FileSystem from "effect/FileSystem";
5	import { resolveAttachmentPath } from "../attachmentStore.ts";
6	import { ProviderValidationError } from "./Errors.ts";
7
8	const quoteReference = Schema.encodeSync(Schema.fromJsonString(Schema.String));
9
10	/** Keep provider answer protocols unchanged; paths refer to files on the provider's server. */
11	export const appendUserInputAttachmentPaths = Effect.fn("appendUserInputAttachmentPaths")(
12	function* (input: {
13	answers: ProviderUserInputAnswers;
14	attachmentsByQuestionId?: UserInputAttachments \| undefined;
15	attachmentsDir: string;
16	}) {
17	const answers = new Map(Object.entries(input.answers));
18	const fs = yield* FileSystem.FileSystem;
19	for (const [questionId, attachments] of Object.entries(input.attachmentsByQuestionId ?? {})) {
20	if (attachments.length === 0) continue;
21	const references: string[] = [];
22	for (const attachment of attachments) {
23	const path = resolveAttachmentPath({ attachmentsDir: input.attachmentsDir, attachment });
24	if (
25	!path \|\|
26	!(yield* fs.exists(path).pipe(
27	Effect.mapError(
28	(cause) =>
29	new ProviderValidationError({
30	operation: "respondToUserInput",
31	issue: `Could not access attachment '${attachment.name}'.`,
32	cause,
33	}),
34	),
35	))
36	) {
37	return yield* new ProviderValidationError({
38	operation: "respondToUserInput",
39	issue: `Attachment '${attachment.name}' is no longer available. Attach it again.`,
40	});
41	}
42	references.push(
43	`Attached ${attachment.type} ${quoteReference(attachment.name)}: ${quoteReference(path)}`,
44	);
45	}
46	const answer = answers.get(questionId);
47	const text = references.join("\n");
48	answers.set(
49	questionId,
50	Array.isArray(answer)
51	? [...answer, text]
52	: typeof answer === "string" && answer.length > 0
53	? `${answer}\n\n${text}`
54	: text,
55	);
56	}
57	return Object.fromEntries(answers);
58	},
59	);

apps/web/src/components/ChatView.tsx+189-22

...	@@ -8,6 +8,13 @@ import {	...	@@ -8,6 +8,13 @@ import {
8	import { feedbackBannerItem } from "./chat/ComposerFeedback";	8	import { feedbackBannerItem } from "./chat/ComposerFeedback";
9	import { usageLimitsBannerItem } from "./chat/ComposerUsageLimits";	9	import { usageLimitsBannerItem } from "./chat/ComposerUsageLimits";
10	import { derivePendingRequests } from "@t3tools/client-runtime/pending-requests";	10	import { derivePendingRequests } from "@t3tools/client-runtime/pending-requests";
		11	import {
		12	questionAttachmentDraftId,
		13	questionAttachmentDraftPrefix,
		14	clearQuestionAttachmentDraft,
		15	useQuestionAttachmentPreparation,
		16	} from "../questionAttachments";
		17	import { useAttachmentUploadStore } from "../lib/attachmentUploadQueue";
11	import {	18	import {
12	type AssistantCitation,	19	type AssistantCitation,
13	type ApprovalRequestId,	20	type ApprovalRequestId,
...	@@ -264,7 +271,7 @@ import {	...	@@ -264,7 +271,7 @@ import {
264	finalizePromotedDraftThreadByRef,	271	finalizePromotedDraftThreadByRef,
265	markPromotedDraftThreadByRef,	272	markPromotedDraftThreadByRef,
266	useComposerDraftStore,	273	useComposerDraftStore,
267	type DraftId,	274	DraftId,
268	} from "../composerDraftStore";	275	} from "../composerDraftStore";
269	import {	276	import {
270	appendTerminalContextsToPrompt,	277	appendTerminalContextsToPrompt,
...	@@ -1610,6 +1617,7 @@ export default function ChatView(props: ChatViewProps) {	...	@@ -1610,6 +1617,7 @@ export default function ChatView(props: ChatViewProps) {
1610	null,	1617	null,
1611	);	1618	);
1612	const [respondingRequestIds, setRespondingRequestIds] = useState<ApprovalRequestId[]>([]);	1619	const [respondingRequestIds, setRespondingRequestIds] = useState<ApprovalRequestId[]>([]);
		1620	const userInputResponsesInFlight = useRef(new Set<string>());
1613	const [respondingUserInputRequestIds, setRespondingUserInputRequestIds] = useState<	1621	const [respondingUserInputRequestIds, setRespondingUserInputRequestIds] = useState<
1614	ApprovalRequestId[]	1622	ApprovalRequestId[]
1615	>([]);	1623	>([]);
...	@@ -2310,6 +2318,8 @@ export default function ChatView(props: ChatViewProps) {	...	@@ -2310,6 +2318,8 @@ export default function ChatView(props: ChatViewProps) {
2310	const supportsPullRequests = serverConfig?.environment.capabilities.pullRequests === true;	2318	const supportsPullRequests = serverConfig?.environment.capabilities.pullRequests === true;
2311	const attachmentEnvironmentConfig = environmentById.get(environmentId)?.serverConfig ?? null;	2319	const attachmentEnvironmentConfig = environmentById.get(environmentId)?.serverConfig ?? null;
2312	const attachmentUploadsCapabilityKnown = attachmentEnvironmentConfig !== null;	2320	const attachmentUploadsCapabilityKnown = attachmentEnvironmentConfig !== null;
		2321	const supportsQuestionAttachments =
		2322	attachmentEnvironmentConfig?.environment.capabilities.questionAttachments === true;
2313	const supportsAttachmentUploads =	2323	const supportsAttachmentUploads =
2314	attachmentEnvironmentConfig?.environment.capabilities.attachmentUploads === true;	2324	attachmentEnvironmentConfig?.environment.capabilities.attachmentUploads === true;
2315	const advertisedFileAttachmentBytes =	2325	const advertisedFileAttachmentBytes =
...	@@ -2627,16 +2637,120 @@ export default function ChatView(props: ChatViewProps) {	...	@@ -2627,16 +2637,120 @@ export default function ChatView(props: ChatViewProps) {
2627	[threadActivities],	2637	[threadActivities],
2628	);	2638	);
2629	const activePendingUserInput = pendingUserInputs[0] ?? null;	2639	const activePendingUserInput = pendingUserInputs[0] ?? null;
2630	const activePendingDraftAnswers = useMemo(	2640	const activePendingRequestKey = JSON.stringify([
		2641	environmentId,
		2642	activeThreadId,
		2643	activePendingUserInput?.requestId,
		2644	]);
		2645	const pendingQuestionDraftKeys = useMemo(
2631	() =>	2646	() =>
2632	activePendingUserInput	2647	activeThreadId
2633	? (pendingUserInputAnswersByRequestId[activePendingUserInput.requestId] ??	2648	? pendingUserInputs.flatMap((request) =>
2634	EMPTY_PENDING_USER_INPUT_ANSWERS)	2649	request.questions.map((question) =>
2635	: EMPTY_PENDING_USER_INPUT_ANSWERS,	2650	questionAttachmentDraftId(
2636	[activePendingUserInput, pendingUserInputAnswersByRequestId],	2651	environmentId,
		2652	activeThreadId,
		2653	request.requestId,
		2654	question.id,
		2655	),
		2656	),
		2657	)
		2658	: [],
		2659	[activeThreadId, environmentId, pendingUserInputs],
2637	);	2660	);
		2661	const questionComposerDrafts = useComposerDraftStore(
		2662	useShallow((state) =>
		2663	Object.fromEntries(
		2664	pendingQuestionDraftKeys.map((key) => [key, state.draftsByThreadKey[key]]),
		2665	),
		2666	),
		2667	);
		2668	const questionUploadsBlocked = useAttachmentUploadStore(
		2669	useShallow((state) =>
		2670	Object.fromEntries(
		2671	pendingQuestionDraftKeys.map((key) => {
		2672	const draft = questionComposerDrafts[key];
		2673	const attachments = draft ? [...draft.images, ...draft.files] : [];
		2674	return [
		2675	key,
		2676	attachments.some((attachment) => {
		2677	const upload = state.uploadsByImageId[attachment.id];
		2678	return upload?.status !== "ready" \|\| upload.environmentId !== environmentId;
		2679	}),
		2680	];
		2681	}),
		2682	),
		2683	),
		2684	);
		2685	const questionPreparations = useQuestionAttachmentPreparation(
		2686	useShallow((state) =>
		2687	Object.fromEntries(pendingQuestionDraftKeys.map((key) => [key, state.counts[key] ?? 0])),
		2688	),
		2689	);
		2690	useEffect(() => {
		2691	if (routeThreadState.status !== "live" \|\| routeThreadState.data._tag !== "Some") return;
		2692	const questionThread = routeThreadState.data.value;
		2693	const { userInputs: currentRequests } = derivePendingRequests(questionThread.activities);
		2694	const prefix = questionAttachmentDraftPrefix(environmentId, questionThread.id);
		2695	const retained = new Set(
		2696	currentRequests.flatMap((request) =>
		2697	request.questions.map((question) =>
		2698	questionAttachmentDraftId(
		2699	environmentId,
		2700	questionThread.id,
		2701	request.requestId,
		2702	question.id,
		2703	),
		2704	),
		2705	),
		2706	);
		2707	const keys = new Set([
		2708	...Object.keys(useComposerDraftStore.getState().draftsByThreadKey),
		2709	...Object.keys(useQuestionAttachmentPreparation.getState().counts),
		2710	]);
		2711	for (const key of keys) {
		2712	if (key.startsWith(prefix) && !retained.has(DraftId.make(key)))
		2713	clearQuestionAttachmentDraft(DraftId.make(key));
		2714	}
		2715	}, [environmentId, routeThreadState.data, routeThreadState.status]);
		2716	const activePendingDraftAnswers = useMemo(() => {
		2717	if (!activePendingUserInput \|\| !activeThreadId) return EMPTY_PENDING_USER_INPUT_ANSWERS;
		2718	return Object.fromEntries(
		2719	activePendingUserInput.questions.map((question) => {
		2720	const key = questionAttachmentDraftId(
		2721	environmentId,
		2722	activeThreadId,
		2723	activePendingUserInput.requestId,
		2724	question.id,
		2725	);
		2726	const draft = questionComposerDrafts[key];
		2727	const attachments = draft ? [...draft.images, ...draft.files] : [];
		2728	return [
		2729	question.id,
		2730	{
		2731	...pendingUserInputAnswersByRequestId[activePendingRequestKey]?.[question.id],
		2732	attachmentCount: attachments.length,
		2733	attachmentsBlocked:
		2734	(attachments.length > 0 && !supportsQuestionAttachments) \|\|
		2735	(questionPreparations[key] ?? 0) > 0 \|\|
		2736	questionUploadsBlocked[key] === true,
		2737	},
		2738	];
		2739	}),
		2740	);
		2741	}, [
		2742	activePendingUserInput,
		2743	activeThreadId,
		2744	environmentId,
		2745	questionComposerDrafts,
		2746	questionUploadsBlocked,
		2747	supportsQuestionAttachments,
		2748	questionPreparations,
		2749	pendingUserInputAnswersByRequestId,
		2750	activePendingRequestKey,
		2751	]);
2638	const activePendingQuestionIndex = activePendingUserInput	2752	const activePendingQuestionIndex = activePendingUserInput
2639	? (pendingUserInputQuestionIndexByRequestId[activePendingUserInput.requestId] ?? 0)	2753	? (pendingUserInputQuestionIndexByRequestId[activePendingRequestKey] ?? 0)
2640	: 0;	2754	: 0;
2641	const activePendingProgress = useMemo(	2755	const activePendingProgress = useMemo(
2642	() =>	2756	() =>
...	@@ -7061,8 +7175,38 @@ export default function ChatView(props: ChatViewProps) {	...	@@ -7061,8 +7175,38 @@ export default function ChatView(props: ChatViewProps) {
7061		7175
7062	const onRespondToUserInput = useCallback(	7176	const onRespondToUserInput = useCallback(
7063	async (requestId: ApprovalRequestId, answers: Record<string, unknown>) => {	7177	async (requestId: ApprovalRequestId, answers: Record<string, unknown>) => {
7064	if (!activeThreadId) return;	7178	if (!activeThreadId \|\| !activePendingUserInput \|\| activePendingIsResponding) return;
7065		7179	const responseKey = JSON.stringify([environmentId, activeThreadId, requestId]);
		7180	if (userInputResponsesInFlight.current.has(responseKey)) return;
		7181	const attachmentsByQuestionId = new Map<
		7182	string,
		7183	import("@t3tools/contracts").UserInputAttachments[string]
		7184	>();
		7185	for (const question of activePendingUserInput.questions) {
		7186	const target = questionAttachmentDraftId(
		7187	environmentId,
		7188	activeThreadId,
		7189	requestId,
		7190	question.id,
		7191	);
		7192	if ((useQuestionAttachmentPreparation.getState().counts[target] ?? 0) > 0) return;
		7193	const draft = useComposerDraftStore.getState().getComposerDraft(target);
		7194	const attachments = draft ? [...draft.images, ...draft.files] : [];
		7195	if (attachments.length === 0) continue;
		7196	const uploaded = getUploadedAttachments({ environmentId, images: attachments });
		7197	if (!uploaded) {
		7198	setThreadError(
		7199	activeThreadId,
		7200	"Wait for attachments to finish uploading, or remove failed uploads.",
		7201	);
		7202	return;
		7203	}
		7204	attachmentsByQuestionId.set(
		7205	question.id,
		7206	uploaded as import("@t3tools/contracts").UserInputAttachments[string],
		7207	);
		7208	}
		7209	userInputResponsesInFlight.current.add(responseKey);
7066	setRespondingUserInputRequestIds((existing) =>	7210	setRespondingUserInputRequestIds((existing) =>
7067	existing.includes(requestId) ? existing : [...existing, requestId],	7211	existing.includes(requestId) ? existing : [...existing, requestId],
7068	);	7212	);
...	@@ -7072,6 +7216,9 @@ export default function ChatView(props: ChatViewProps) {	...	@@ -7072,6 +7216,9 @@ export default function ChatView(props: ChatViewProps) {
7072	threadId: activeThreadId,	7216	threadId: activeThreadId,
7073	requestId,	7217	requestId,
7074	answers,	7218	answers,
		7219	...(attachmentsByQuestionId.size > 0
		7220	? { attachmentsByQuestionId: Object.fromEntries(attachmentsByQuestionId) }
		7221	: {}),
7075	},	7222	},
7076	});	7223	});
7077	if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {	7224	if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
...	@@ -7081,10 +7228,18 @@ export default function ChatView(props: ChatViewProps) {	...	@@ -7081,10 +7228,18 @@ export default function ChatView(props: ChatViewProps) {
7081	error instanceof Error ? error.message : "Failed to submit user input.",	7228	error instanceof Error ? error.message : "Failed to submit user input.",
7082	);	7229	);
7083	}	7230	}
		7231	userInputResponsesInFlight.current.delete(responseKey);
7084	setRespondingUserInputRequestIds((existing) => existing.filter((id) => id !== requestId));	7232	setRespondingUserInputRequestIds((existing) => existing.filter((id) => id !== requestId));
7085	return result;	7233	return result;
7086	},	7234	},
7087	[activeThreadId, environmentId, respondToThreadUserInput, setThreadError],	7235	[
		7236	activeThreadId,
		7237	activePendingUserInput,
		7238	activePendingIsResponding,
		7239	environmentId,
		7240	respondToThreadUserInput,
		7241	setThreadError,
		7242	],
7088	);	7243	);
7089		7244
7090	// Closes an async question without messaging the agent. The server records	7245	// Closes an async question without messaging the agent. The server records
...	@@ -7120,10 +7275,10 @@ export default function ChatView(props: ChatViewProps) {	...	@@ -7120,10 +7275,10 @@ export default function ChatView(props: ChatViewProps) {
7120	}	7275	}
7121	setPendingUserInputQuestionIndexByRequestId((existing) => ({	7276	setPendingUserInputQuestionIndexByRequestId((existing) => ({
7122	...existing,	7277	...existing,
7123	[activePendingUserInput.requestId]: nextQuestionIndex,	7278	[activePendingRequestKey]: nextQuestionIndex,
7124	}));	7279	}));
7125	},	7280	},
7126	[activePendingUserInput],	7281	[activePendingUserInput, activePendingRequestKey],
7127	);	7282	);
7128		7283
7129	const onSelectActivePendingUserInputOption = useCallback(	7284	const onSelectActivePendingUserInputOption = useCallback(
...	@@ -7143,11 +7298,11 @@ export default function ChatView(props: ChatViewProps) {	...	@@ -7143,11 +7298,11 @@ export default function ChatView(props: ChatViewProps) {
7143		7298
7144	return {	7299	return {
7145	...existing,	7300	...existing,
7146	[activePendingUserInput.requestId]: {	7301	[activePendingRequestKey]: {
7147	...existing[activePendingUserInput.requestId],	7302	...existing[activePendingRequestKey],
7148	[questionId]: togglePendingUserInputOptionSelection(	7303	[questionId]: togglePendingUserInputOptionSelection(
7149	question,	7304	question,
7150	existing[activePendingUserInput.requestId]?.[questionId],	7305	existing[activePendingRequestKey]?.[questionId],
7151	optionValue,	7306	optionValue,
7152	),	7307	),
7153	},	7308	},
...	@@ -7156,7 +7311,12 @@ export default function ChatView(props: ChatViewProps) {	...	@@ -7156,7 +7311,12 @@ export default function ChatView(props: ChatViewProps) {
7156	promptRef.current = "";	7311	promptRef.current = "";
7157	composerRef.current?.resetCursorState({ cursor: 0 });	7312	composerRef.current?.resetCursorState({ cursor: 0 });
7158	},	7313	},
7159	[activePendingProgress?.activeQuestion, activePendingUserInput, composerRef],	7314	[
		7315	activePendingProgress?.activeQuestion,
		7316	activePendingUserInput,
		7317	activePendingRequestKey,
		7318	composerRef,
		7319	],
7160	);	7320	);
7161		7321
7162	const onChangeActivePendingUserInputCustomAnswer = useCallback(	7322	const onChangeActivePendingUserInputCustomAnswer = useCallback(
...	@@ -7177,10 +7337,10 @@ export default function ChatView(props: ChatViewProps) {	...	@@ -7177,10 +7337,10 @@ export default function ChatView(props: ChatViewProps) {
7177	promptRef.current = value;	7337	promptRef.current = value;
7178	setPendingUserInputAnswersByRequestId((existing) => ({	7338	setPendingUserInputAnswersByRequestId((existing) => ({
7179	...existing,	7339	...existing,
7180	[activePendingUserInput.requestId]: {	7340	[activePendingRequestKey]: {
7181	...existing[activePendingUserInput.requestId],	7341	...existing[activePendingRequestKey],
7182	[questionId]: setPendingUserInputCustomAnswer(	7342	[questionId]: setPendingUserInputCustomAnswer(
7183	existing[activePendingUserInput.requestId]?.[questionId],	7343	existing[activePendingRequestKey]?.[questionId],
7184	value,	7344	value,
7185	),	7345	),
7186	},	7346	},
...	@@ -7194,11 +7354,16 @@ export default function ChatView(props: ChatViewProps) {	...	@@ -7194,11 +7354,16 @@ export default function ChatView(props: ChatViewProps) {
7194	composerRef.current?.focusAt(nextCursor);	7354	composerRef.current?.focusAt(nextCursor);
7195	}	7355	}
7196	},	7356	},
7197	[activePendingUserInput, composerRef],	7357	[activePendingUserInput, activePendingRequestKey, composerRef],
7198	);	7358	);
7199		7359
7200	const onAdvanceActivePendingUserInput = useCallback(() => {	7360	const onAdvanceActivePendingUserInput = useCallback(() => {
7201	if (!activePendingUserInput \|\| !activePendingProgress) {	7361	if (
		7362	!activePendingUserInput \|\|
		7363	!activePendingProgress \|\|
		7364	!activePendingProgress.canAdvance \|\|
		7365	activePendingIsResponding
		7366	) {
7202	return;	7367	return;
7203	}	7368	}
7204	if (activePendingProgress.isLastQuestion) {	7369	if (activePendingProgress.isLastQuestion) {
...	@@ -7212,6 +7377,7 @@ export default function ChatView(props: ChatViewProps) {	...	@@ -7212,6 +7377,7 @@ export default function ChatView(props: ChatViewProps) {
7212	activePendingProgress,	7377	activePendingProgress,
7213	activePendingResolvedAnswers,	7378	activePendingResolvedAnswers,
7214	activePendingUserInput,	7379	activePendingUserInput,
		7380	activePendingIsResponding,
7215	onRespondToUserInput,	7381	onRespondToUserInput,
7216	setActivePendingUserInputQuestionIndex,	7382	setActivePendingUserInputQuestionIndex,
7217	]);	7383	]);
...	@@ -8119,6 +8285,7 @@ export default function ChatView(props: ChatViewProps) {	...	@@ -8119,6 +8285,7 @@ export default function ChatView(props: ChatViewProps) {
8119	environmentId={environmentId}	8285	environmentId={environmentId}
8120	attachmentUploadsCapabilityKnown={attachmentUploadsCapabilityKnown}	8286	attachmentUploadsCapabilityKnown={attachmentUploadsCapabilityKnown}
8121	supportsAttachmentUploads={supportsAttachmentUploads}	8287	supportsAttachmentUploads={supportsAttachmentUploads}
		8288	supportsQuestionAttachments={supportsQuestionAttachments}
8122	maxFileAttachmentBytes={maxFileAttachmentBytes}	8289	maxFileAttachmentBytes={maxFileAttachmentBytes}
8123	routeKind={routeKind}	8290	routeKind={routeKind}
8124	routeThreadRef={routeThreadRef}	8291	routeThreadRef={routeThreadRef}

apps/web/src/components/chat/ChatComposer.tsx+156-47

 @@ -1,4 +1,9 @@
 import { RefreshIcon } from "~/components/ui/refresh-icon";
+import {
+  questionAttachmentDraftId,
+  useQuestionAttachmentPreparation,
+  changeQuestionAttachmentPreparation,
+} from "../../questionAttachments";
 import type {
   ApprovalRequestId,
   AssistantCitation,
 @@ -1227,6 +1232,7 @@ export interface ChatComposerProps {
   environmentId: EnvironmentId;
   attachmentUploadsCapabilityKnown: boolean;
   supportsAttachmentUploads: boolean;
+  supportsQuestionAttachments: boolean;
   maxFileAttachmentBytes: number | null;
   routeKind: "server" | "draft";
   routeThreadRef: ScopedThreadRef;
 @@ -1376,6 +1382,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     environmentId,
     attachmentUploadsCapabilityKnown,
     supportsAttachmentUploads,
+    supportsQuestionAttachments,
     maxFileAttachmentBytes,
     routeKind,
     routeThreadRef,
 @@ -1468,9 +1475,22 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
   // happened while they awaited.
   const composerDraftTargetKeyRef = useRef("");
   composerDraftTargetKeyRef.current = composerTargetKey(composerDraftTarget);
+  const questionAttachmentTarget =
+    pendingUserInputs[0] && activePendingProgress?.activeQuestion
+      ? questionAttachmentDraftId(
+          environmentId,
+          activeThreadId!,
+          pendingUserInputs[0].requestId,
+          activePendingProgress.activeQuestion.id,
+        )
+      : null;
+  const attachmentDraftTarget = questionAttachmentTarget ?? composerDraftTarget;
+  const attachmentDraft = useComposerThreadDraft(attachmentDraftTarget);
+  const attachmentTargetKey = composerTargetKey(attachmentDraftTarget);
+  const questionPreparations = useQuestionAttachmentPreparation((state) => state.counts);
   const prompt = composerDraft.prompt;
-  const composerImages = composerDraft.images;
+  const composerImages = attachmentDraft.images;
-  const composerFiles = composerDraft.files;
+  const composerFiles = attachmentDraft.files;
   const composerVideos = composerFiles.filter((file) =>
     isPreviewableComposerVideo(file, environmentId),
   );
 @@ -1500,7 +1520,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     );
     return composerImages.filter((image) => !previewAnnotationIds.has(image.id));
   }, [composerImages, composerPreviewAnnotations]);
-  const nonPersistedComposerImageIds = composerDraft.nonPersistedImageIds;
+  const nonPersistedComposerImageIds = attachmentDraft.nonPersistedImageIds;
   const uploadsByImageId = useAttachmentUploadStore((state) => state.uploadsByImageId);
   const needsReattachFileCount = composerFiles.filter(composerFileNeedsReattach).length;
   const fileStagingLimit = fileAttachmentStagingLimit({
 @@ -1515,6 +1535,11 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     maxFileAttachmentBytes,
   });
   const attachmentBlockReason =
+    (questionAttachmentTarget &&
+    !supportsQuestionAttachments &&
+    (composerImages.length > 0 || composerFiles.length > 0)
+      ? "Update this server to send files with question answers"
+      : null) ??
     fileCapabilityBlockReason ??
     (supportsAttachmentUploads
       ? needsReattachFileCount > 0
 @@ -1528,7 +1553,6 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
           })
       : null);
   const setComposerDraftPrompt = useComposerDraftStore((store) => store.setPrompt);
-  const addComposerDraftImage = useComposerDraftStore((store) => store.addImage);
   const addComposerDraftImages = useComposerDraftStore((store) => store.addImages);
   const removeComposerDraftImage = useComposerDraftStore((store) => store.removeImage);
   const addComposerDraftFiles = useComposerDraftStore((store) => store.addFiles);
 @@ -1596,11 +1620,15 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
       if (attachment.type === "file" && composerFileNeedsReattach(attachment)) {
         continue;
       }
-      startAttachmentUpload({ environmentId, image: attachment, draftTarget: composerDraftTarget });
+      startAttachmentUpload({
+        environmentId,
+        image: attachment,
+        draftTarget: attachmentDraftTarget,
+      });
     }
   }, [
     attachmentUploadsCapabilityKnown,
-    composerDraftTarget,
+    attachmentDraftTarget,
     composerFiles,
     composerImages,
     environmentId,
 @@ -1621,7 +1649,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
       const upload = uploadsByImageId[file.id];
       if (upload?.status === "ready" && upload.environmentId === environmentId) {
         setComposerDraftFileUpload(
-          composerDraftTarget,
+          attachmentDraftTarget,
           file.id,
           environmentId,
           upload.attachmentId,
 @@ -1630,7 +1658,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     }
   }, [
     attachmentUploadsCapabilityKnown,
-    composerDraftTarget,
+    attachmentDraftTarget,
     composerFiles,
     environmentId,
     maxFileAttachmentBytes,
 @@ -1713,7 +1741,9 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
   );
   const sendDisabledReason =
     externalSendDisabledReason ??
-    (activePendingProgress ? null : (attachmentBlockReason ?? providerSendBlockReason));
+    (activePendingProgress
+      ? attachmentBlockReason
+      : (attachmentBlockReason ?? providerSendBlockReason));
   const isSendDisabled = sendDisabledReason !== null;
   const selectedProviderStatus = useMemo(
     () => selectedProviderEntry?.snapshot ?? null,
 @@ -1938,7 +1968,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
    * and checked before sending or compacting so an image cannot move into
    * the next draft.
    */
-  const pendingImageCompressionsRef = useRef<Map<ThreadId, number>>(new Map());
+  const pendingImageCompressionsRef = useRef<Map<string, number>>(new Map());
   // ------------------------------------------------------------------
   // Derived: composer send state
 @@ -2127,7 +2157,11 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     (!isComposerCollapsedMobile && showPlanFollowUpPrompt && activeProposedPlan !== null);
   const showCollapsedMobilePromptRow =
     isComposerCollapsedMobile && !isComposerApprovalState && pendingUserInputs.length === 0;
-  const showComposerAttachAction = fileStagingLimit !== null && pendingUserInputs.length === 0;
+  const showComposerAttachAction =
+    fileStagingLimit !== null &&
+    (!activePendingProgress ||
+      (supportsQuestionAttachments &&
+        activePendingProgress.activeQuestion?.allowCustomAnswer !== false));
   const composerFooterHasWideActions = showPlanFollowUpPrompt || activePendingProgress !== null;
   const composerFooterActionLayoutKey = useMemo(() => {
     if (activePendingProgress) {
 @@ -2219,12 +2253,22 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
         ? {
             questionIndex: activePendingProgress.questionIndex,
             isLastQuestion: activePendingProgress.isLastQuestion,
-            canAdvance: activePendingProgress.canAdvance,
+            canAdvance:
+              activePendingProgress.canAdvance &&
+              !attachmentBlockReason &&
+              !(questionPreparations[attachmentTargetKey] ?? 0),
             isResponding: activePendingIsResponding,
             isComplete: Boolean(activePendingResolvedAnswers),
           }
         : null,
-    [activePendingIsResponding, activePendingProgress, activePendingResolvedAnswers],
+    [
+      activePendingIsResponding,
+      activePendingProgress,
+      activePendingResolvedAnswers,
+      attachmentBlockReason,
+      questionPreparations,
+      attachmentTargetKey,
+    ],
   );
   const collapsedComposerPrimaryActionDisabled =
     phase === "running" ||
 @@ -2251,35 +2295,42 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
   const addComposerImage = useCallback(
     (image: ComposerImageAttachment) => {
-      addComposerDraftImage(composerDraftTarget, image);
+      addComposerDraftImages(attachmentDraftTarget, [image]);
     },
-    [composerDraftTarget, addComposerDraftImage],
+    [attachmentDraftTarget, addComposerDraftImages],
   );
   const addComposerImagesToDraft = useCallback(
     (images: ComposerImageAttachment[]) => {
-      addComposerDraftImages(composerDraftTarget, images);
+      addComposerDraftImages(attachmentDraftTarget, images);
     },
-    [composerDraftTarget, addComposerDraftImages],
+    [attachmentDraftTarget, addComposerDraftImages],
   );
   const addComposerFilesToDraft = useCallback(
     (files: ComposerFileAttachment[]) => {
-      addComposerDraftFiles(composerDraftTarget, files);
+      addComposerDraftFiles(attachmentDraftTarget, files);
     },
-    [addComposerDraftFiles, composerDraftTarget],
+    [addComposerDraftFiles, attachmentDraftTarget],
   );
   const removeComposerImageFromDraft = useCallback(
     (imageId: string) => {
+      if (questionAttachmentTarget && activePendingIsResponding) return;
       releaseAttachmentUpload(imageId);
-      removeComposerDraftImage(composerDraftTarget, imageId);
+      removeComposerDraftImage(attachmentDraftTarget, imageId);
     },
-    [composerDraftTarget, removeComposerDraftImage],
+    [
+      attachmentDraftTarget,
+      questionAttachmentTarget,
+      activePendingIsResponding,
+      removeComposerDraftImage,
+    ],
   );
   const removeComposerFileFromDraft = useCallback(
     (fileId: string) => {
+      if (questionAttachmentTarget && activePendingIsResponding) return;
       // Release by the draft attachment, not the bare queue key: a hydrated
       // file's upload lives server-side under its persisted attachment id.
       const file = composerFilesRef.current.find((candidate) => candidate.id === fileId);
 @@ -2288,9 +2339,15 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
       } else {
         releaseAttachmentUpload(fileId);
       }
-      removeComposerDraftFile(composerDraftTarget, fileId);
+      removeComposerDraftFile(attachmentDraftTarget, fileId);
     },
-    [composerDraftTarget, composerFilesRef, removeComposerDraftFile],
+    [
+      attachmentDraftTarget,
+      questionAttachmentTarget,
+      activePendingIsResponding,
+      composerFilesRef,
+      removeComposerDraftFile,
+    ],
   );
   const removeComposerTerminalContextFromDraft = useCallback(
 @@ -2525,11 +2582,11 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     let cancelled = false;
     void (async () => {
       if (composerImages.length === 0) {
-        clearComposerDraftPersistedAttachments(composerDraftTarget);
+        clearComposerDraftPersistedAttachments(attachmentDraftTarget);
         return;
       }
       const getPersistedAttachmentsForThread = () =>
-        getComposerDraft(composerDraftTarget)?.persistedAttachments ?? [];
+        getComposerDraft(attachmentDraftTarget)?.persistedAttachments ?? [];
       try {
         const currentPersistedAttachments = getPersistedAttachmentsForThread();
         const existingPersistedById = new Map(
 @@ -2558,7 +2615,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
         );
         const serialized = Array.from(stagedAttachmentById.values());
         if (cancelled) return;
-        syncComposerDraftPersistedAttachments(composerDraftTarget, serialized);
+        syncComposerDraftPersistedAttachments(attachmentDraftTarget, serialized);
       } catch {
         const currentImageIds = new Set(composerImages.map((image) => image.id));
         const fallbackPersistedAttachments = getPersistedAttachmentsForThread();
 @@ -2573,14 +2630,14 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
           fallbackPersistedIdSet.has(attachment.id),
         );
         if (cancelled) return;
-        syncComposerDraftPersistedAttachments(composerDraftTarget, fallbackAttachments);
+        syncComposerDraftPersistedAttachments(attachmentDraftTarget, fallbackAttachments);
       }
     })();
     return () => {
       cancelled = true;
     };
   }, [
-    composerDraftTarget,
+    attachmentDraftTarget,
     clearComposerDraftPersistedAttachments,
     composerImages,
     getComposerDraft,
 @@ -2946,7 +3003,10 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
       // image: the turn snapshot wouldn't include it, and it would surface
       // in the *next* draft instead. Only oversized images hit this — small
       // files clear the pending counter within a microtask.
-      if (activeThreadId && (pendingImageCompressionsRef.current.get(activeThreadId) ?? 0) > 0) {
+      if (
+        activeThreadId &&
+        (pendingImageCompressionsRef.current.get(attachmentTargetKey) ?? 0) > 0
+      ) {
         event?.preventDefault();
         toastManager.add({
           type: "info",
 @@ -2976,6 +3036,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     [
       activeThreadId,
       activePendingProgress,
+      attachmentTargetKey,
       blurMobileComposerAfterSend,
       isSendDisabled,
       noProviderAvailable,
 @@ -3009,7 +3070,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     // The compact buttons cannot see the compression counter (it lives in
     // a ref), so they render enabled during a paste; toast instead of
     // silently ignoring the click.
-    if ((pendingImageCompressionsRef.current.get(activeThreadId) ?? 0) > 0) {
+    if ((pendingImageCompressionsRef.current.get(attachmentTargetKey) ?? 0) > 0) {
       toastManager.add({
         type: "info",
         title: "Still compressing a pasted image.",
 @@ -4255,10 +4316,15 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
   // ------------------------------------------------------------------
   const addComposerAttachments = async (files: File[]) => {
     if (!activeThreadId || files.length === 0) return;
-    if (pendingUserInputs.length > 0) {
+    if (
+      pendingUserInputs.length > 0 &&
+      (!supportsQuestionAttachments ||
+        activePendingProgress?.activeQuestion?.allowCustomAnswer === false ||
+        activePendingIsResponding)
+    ) {
       toastManager.add({
         type: "error",
-        title: "Attach files after answering pending questions.",
+        title: "This question cannot accept attachments.",
       });
       return;
     }
 @@ -4270,9 +4336,31 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     // Validation happens synchronously so concurrent pastes see each other:
     // accepted files reserve their attachment slots (via the pending counter)
     // before the first await, keeping the total under the limit.
-    const pendingCount = pendingImageCompressionsRef.current.get(threadId) ?? 0;
+    const pendingCount = pendingImageCompressionsRef.current.get(attachmentTargetKey) ?? 0;
+    const otherQuestionAttachments =
+      questionAttachmentTarget && pendingUserInputs[0]
+        ? pendingUserInputs[0].questions.reduce((count, question) => {
+            const target = questionAttachmentDraftId(
+              environmentId,
+              threadId,
+              pendingUserInputs[0]!.requestId,
+              question.id,
+            );
+            if (target === questionAttachmentTarget) return count;
+            const draft = getComposerDraft(target);
+            return (
+              count +
+              (draft?.images.length ?? 0) +
+              (draft?.files.length ?? 0) +
+              (useQuestionAttachmentPreparation.getState().counts[target] ?? 0)
+            );
+          }, 0)
+        : 0;
     let reservedCount =
-      composerImagesRef.current.length + composerFilesRef.current.length + pendingCount;
+      composerImagesRef.current.length +
+      composerFilesRef.current.length +
+      pendingCount +
+      otherQuestionAttachments;
     // A pick that matches a needs-reattach marker replaces it in the draft, so
     // it must not consume a slot; a draft full of markers would otherwise hit
     // the capacity error before the replacement path could run.
 @@ -4351,7 +4439,12 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     }
     if (acceptedImages.length === 0) return;
-    pendingImageCompressionsRef.current.set(threadId, pendingCount + acceptedImages.length);
+    pendingImageCompressionsRef.current.set(
+      attachmentTargetKey,
+      pendingCount + acceptedImages.length,
+    );
+    if (questionAttachmentTarget)
+      changeQuestionAttachmentPreparation(questionAttachmentTarget, acceptedImages.length);
     try {
       const nextImages: ComposerImageAttachment[] = [];
       let compressionError: string | null = null;
 @@ -4381,6 +4474,13 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
           file: attachmentFile,
         });
       }
+      if (
+        questionAttachmentTarget &&
+        !useQuestionAttachmentPreparation.getState().counts[questionAttachmentTarget]
+      ) {
+        for (const image of nextImages) URL.revokeObjectURL(image.previewUrl);
+        return;
+      }
       if (nextImages.length === 1 && nextImages[0]) {
         addComposerImage(nextImages[0]);
       } else if (nextImages.length > 1) {
 @@ -4394,12 +4494,14 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
         setThreadError(threadId, compressionError);
       }
     } finally {
+      if (questionAttachmentTarget)
+        changeQuestionAttachmentPreparation(questionAttachmentTarget, -acceptedImages.length);
       const remaining =
-        (pendingImageCompressionsRef.current.get(threadId) ?? 0) - acceptedImages.length;
+        (pendingImageCompressionsRef.current.get(attachmentTargetKey) ?? 0) - acceptedImages.length;
       if (remaining > 0) {
-        pendingImageCompressionsRef.current.set(threadId, remaining);
+        pendingImageCompressionsRef.current.set(attachmentTargetKey, remaining);
       } else {
-        pendingImageCompressionsRef.current.delete(threadId);
+        pendingImageCompressionsRef.current.delete(attachmentTargetKey);
       }
     }
   };
 @@ -4909,7 +5011,11 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
                 ) : !isComposerCollapsedMobile && pendingUserInputs.length > 0 ? (
                   <ComposerPendingUserInputPanel
                     pendingUserInputs={pendingUserInputs}
-                    respondingRequestIds={respondingRequestIds}
+                    respondingRequestIds={
+                      activePendingIsResponding && activePendingUserInput
+                        ? [...respondingRequestIds, activePendingUserInput.requestId]
+                        : respondingRequestIds
+                    }
                     answers={activePendingDraftAnswers}
                     questionIndex={activePendingQuestionIndex}
                     onToggleOption={onSelectActivePendingUserInputOption}
 @@ -4925,7 +5031,11 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
                   <div data-chat-composer-collapsed-controls="true">
                     <ComposerPendingUserInputPanel
                       pendingUserInputs={pendingUserInputs}
-                      respondingRequestIds={respondingRequestIds}
+                      respondingRequestIds={
+                        activePendingIsResponding && activePendingUserInput
+                          ? [...respondingRequestIds, activePendingUserInput.requestId]
+                          : respondingRequestIds
+                      }
                       answers={activePendingDraftAnswers}
                       questionIndex={activePendingQuestionIndex}
                       onToggleOption={onSelectActivePendingUserInputOption}
 @@ -5148,7 +5258,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
                             retryAttachmentUpload({
                               environmentId,
                               image,
-                              draftTarget: composerDraftTarget,
+                              draftTarget: attachmentDraftTarget,
                             }),
                         }
                       : {})}
 @@ -5192,7 +5302,6 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
               {!isComposerCollapsedMobile &&
                 !isComposerApprovalState &&
-                pendingUserInputs.length === 0 &&
                 (uncommittedSnapShotIds.length > 0 ||
                   composerVideos.length > 0 ||
                   expandedComposerImages.length > 0) && (
 @@ -5310,7 +5419,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
                                         retryAttachmentUpload({
                                           environmentId,
                                           image,
-                                          draftTarget: composerDraftTarget,
+                                          draftTarget: attachmentDraftTarget,
                                         })
                                       }
                                       aria-label={`Retry upload for ${image.name}`}
 @@ -5410,7 +5519,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
                                       retryAttachmentUpload({
                                         environmentId,
                                         image: file,
-                                        draftTarget: composerDraftTarget,
+                                        draftTarget: attachmentDraftTarget,
                                       })
                                     }
                                     aria-label={`Retry upload for ${file.name}`}
 @@ -5444,7 +5553,6 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
               {!isComposerCollapsedMobile &&
                 !isComposerApprovalState &&
-                pendingUserInputs.length === 0 &&
                 composerOtherFiles.length > 0 && (
                   <div className="mb-3 flex flex-col gap-1">
                     {composerOtherFiles.map((file) => {
 @@ -5487,7 +5595,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
                                       retryAttachmentUpload({
                                         environmentId,
                                         image: file,
-                                        draftTarget: composerDraftTarget,
+                                        draftTarget: attachmentDraftTarget,
                                       })
                                     }
                                     aria-label={`Retry upload for ${file.name}`}
 @@ -5587,7 +5695,8 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
                     isConnecting ||
                     isComposerApprovalState ||
                     projectSelectionRequired ||
-                    isChoiceOnlyPendingQuestion
+                    isChoiceOnlyPendingQuestion ||
+                    activePendingIsResponding
                   }
                 />
                 {isComposerResting ? collapsedComposerImagePreviews : null}

apps/web/src/components/chat/MessagesTimeline.test.tsx+76-1

...	@@ -1,4 +1,10 @@	...	@@ -1,4 +1,10 @@
1	import { CheckpointRef, EnvironmentId, MessageId, TurnId } from "@t3tools/contracts";	1	import {
		2	ApprovalRequestId,
		3	CheckpointRef,
		4	EnvironmentId,
		5	MessageId,
		6	TurnId,
		7	} from "@t3tools/contracts";
2	import { act, createRef, useLayoutEffect, type ReactNode, type Ref } from "react";	8	import { act, createRef, useLayoutEffect, type ReactNode, type Ref } from "react";
3	import { renderToStaticMarkup } from "react-dom/server";	9	import { renderToStaticMarkup } from "react-dom/server";
4	import { create, type ReactTestRenderer } from "react-test-renderer";	10	import { create, type ReactTestRenderer } from "react-test-renderer";
...	@@ -266,6 +272,75 @@ function buildSnapShotTimelineEntry(previewUrl?: string) {	...	@@ -266,6 +272,75 @@ function buildSnapShotTimelineEntry(previewUrl?: string) {
266	}	272	}
267		273
268	describe("MessagesTimeline", () => {	274	describe("MessagesTimeline", () => {
		275	// Expanding history uses this suite's existing test renderer, deprecated in
		276	// React 19. Migrate these interaction tests together when a DOM test setup is added.
		277	it.each([{}, { text: "Text-only answer", file: "Answer with a file" }])(
		278	"renders attachment-only question history alongside text answers: %j",
		279	async (answers) => {
		280	vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
		281	vi.stubGlobal("requestAnimationFrame", () => 0);
		282	vi.stubGlobal("cancelAnimationFrame", () => {});
		283	let renderer: ReactTestRenderer \| undefined;
		284	try {
		285	await act(() => {
		286	renderer = create(
		287	<MessagesTimeline
		288	{...buildProps()}
		289	timelineEntries={[
		290	{
		291	id: "answer-entry",
		292	kind: "work",
		293	createdAt: MESSAGE_CREATED_AT,
		294	entry: {
		295	id: "answer-work",
		296	createdAt: MESSAGE_CREATED_AT,
		297	label: "Question answer submitted",
		298	tone: "info",
		299	questionAnswer: {
		300	requestId: ApprovalRequestId.make("question-request"),
		301	answers,
		302	questionTextById: { file: "Provide a spec", image: "Provide a screenshot" },
		303	attachmentsByQuestionId: {
		304	file: [
		305	{
		306	type: "file",
		307	id: "spec",
		308	name: "spec.txt",
		309	mimeType: "text/plain",
		310	sizeBytes: 4,
		311	},
		312	],
		313	image: [
		314	{
		315	type: "image",
		316	id: "shot",
		317	name: "shot.png",
		318	mimeType: "image/png",
		319	sizeBytes: 4,
		320	},
		321	],
		322	},
		323	},
		324	},
		325	},
		326	]}
		327	/>,
		328	);
		329	});
		330	const toggle = renderer!.root.findByProps({ "aria-expanded": false });
		331	await act(() => toggle.props.onClick());
		332	const markup = JSON.stringify(renderer!.toJSON());
		333	expect(markup.match(/Provide a spec/g)).toHaveLength(1);
		334	expect(markup.match(/spec\.txt/g)).toHaveLength(1);
		335	expect(markup).toContain("Provide a screenshot");
		336	expect(markup).toContain("shot.png");
		337	for (const answer of Object.values(answers)) expect(markup).toContain(answer);
		338	} finally {
		339	await act(() => renderer?.unmount());
		340	}
		341	},
		342	);
		343
269	it.each([	344	it.each([
270	{ toolLifecycleStatus: "inProgress", isAtEnd: true },	345	{ toolLifecycleStatus: "inProgress", isAtEnd: true },
271	{ toolLifecycleStatus: "inProgress", isAtEnd: false },	346	{ toolLifecycleStatus: "inProgress", isAtEnd: false },

apps/web/src/components/chat/MessagesTimeline.tsx+70-1

...	@@ -3216,7 +3216,9 @@ const PlainWorkEntryRow = memo(function PlainWorkEntryRow(props: {	...	@@ -3216,7 +3216,9 @@ const PlainWorkEntryRow = memo(function PlainWorkEntryRow(props: {
3216	showWarningIndicator \|\| showDestructiveRowStyle	3216	showWarningIndicator \|\| showDestructiveRowStyle
3217	? undefined	3217	? undefined
3218	: (workEntry.toolIcon ?? workEntry.toolSource?.icon);	3218	: (workEntry.toolIcon ?? workEntry.toolSource?.icon);
3219	const previewText = displayLabel ?? workEntryDisplayLabel(workEntry, workspaceRoot);	3219	const previewText = workEntry.questionAnswer
		3220	? "Question answer submitted"
		3221	: (displayLabel ?? workEntryDisplayLabel(workEntry, workspaceRoot));
3220	const viewedImagePath = workEntryViewedImagePath(workEntry);	3222	const viewedImagePath = workEntryViewedImagePath(workEntry);
3221	const viewedImage =	3223	const viewedImage =
3222	viewedImagePath && threadRef	3224	viewedImagePath && threadRef
...	@@ -3362,6 +3364,9 @@ const PlainWorkEntryRow = memo(function PlainWorkEntryRow(props: {	...	@@ -3362,6 +3364,9 @@ const PlainWorkEntryRow = memo(function PlainWorkEntryRow(props: {
3362	/>	3364	/>
3363	</div>	3365	</div>
3364	) : null}	3366	) : null}
		3367	{workEntry.questionAnswer ? (
		3368	<QuestionAnswerHistory answer={workEntry.questionAnswer} />
		3369	) : null}
3365	{expanded && canExpand && expandedBody ? (	3370	{expanded && canExpand && expandedBody ? (
3366	<div	3371	<div
3367	className="mt-1 ms-7 cursor-default rounded-md bg-muted/40 px-3 py-2"	3372	className="mt-1 ms-7 cursor-default rounded-md bg-muted/40 px-3 py-2"
...	@@ -3374,3 +3379,67 @@ const PlainWorkEntryRow = memo(function PlainWorkEntryRow(props: {	...	@@ -3374,3 +3379,67 @@ const PlainWorkEntryRow = memo(function PlainWorkEntryRow(props: {
3374	</div>	3379	</div>
3375	);	3380	);
3376	});	3381	});
		3382
		3383	function QuestionAnswerHistory({
		3384	answer,
		3385	}: {
		3386	answer: import("@t3tools/contracts").UserInputAttachmentAnswerPayload;
		3387	}) {
		3388	const { activeThreadEnvironmentId } = use(TimelineRowCtx);
		3389	const attachments = useMemo(() => Object.values(answer.attachmentsByQuestionId).flat(), [answer]);
		3390	const resources = useMemo(
		3391	() =>
		3392	attachments.map((attachment) => ({
		3393	_tag: "attachment" as const,
		3394	attachmentId: attachment.id,
		3395	})),
		3396	[attachments],
		3397	);
		3398	const urls = useAssetUrls(activeThreadEnvironmentId, resources);
		3399	return (
		3400	<div className="ms-7 mt-2 space-y-2" onClick={stopRowToggle}>
		3401	{[
		3402	...new Set([
		3403	...Object.keys(answer.answers),
		3404	...Object.keys(answer.attachmentsByQuestionId),
		3405	]),
		3406	].map((questionId) => (
		3407	<div key={questionId} className="space-y-1">
		3408	{answer.questionTextById?.[questionId] ? (
		3409	<p className="text-sm text-muted-foreground">{answer.questionTextById[questionId]}</p>
		3410	) : null}
		3411	<p className="whitespace-pre-wrap text-sm">
		3412	{[answer.answers[questionId]]
		3413	.flat()
		3414	.filter((value): value is string => typeof value === "string")
		3415	.join(", ")}
		3416	</p>
		3417	<div className="flex flex-wrap gap-2">
		3418	{(answer.attachmentsByQuestionId[questionId] ?? []).map((attachment) => {
		3419	const url = urls[attachments.indexOf(attachment)];
		3420	return (
		3421	<a
		3422	key={attachment.id}
		3423	href={url ?? undefined}
		3424	target="_blank"
		3425	rel="noreferrer"
		3426	className="text-sm underline"
		3427	>
		3428	{attachment.type === "image" && url ? (
		3429	<img
		3430	src={url}
		3431	alt={attachment.name}
		3432	className="h-20 max-w-32 rounded object-contain"
		3433	/>
		3434	) : (
		3435	attachment.name
		3436	)}
		3437	</a>
		3438	);
		3439	})}
		3440	</div>
		3441	</div>
		3442	))}
		3443	</div>
		3444	);
		3445	}

apps/web/src/lib/attachmentUploadQueue.test.ts+26

...	@@ -339,6 +339,32 @@ describe("attachmentUploadQueue", () => {	...	@@ -339,6 +339,32 @@ describe("attachmentUploadQueue", () => {
339	}	339	}
340	});	340	});
341		341
		342	it("persists a retried question upload without a mounted composer", async () => {
		343	const draftId = DraftId.make("question-retry-upload");
		344	const file = makeFile("question-retry");
		345	const store = useComposerDraftStore.getState();
		346	store.addFiles(draftId, [file]);
		347	try {
		348	startAttachmentUpload({ environmentId: firstEnvironment, image: file, draftTarget: draftId });
		349	await Promise.resolve();
		350	let settled = awaitAttachmentUploads([file.id]);
		351	TestXmlHttpRequest.requests[0]!.complete(500);
		352	await settled;
		353	expect(store.getComposerDraft(draftId)?.files[0]?.uploadedAttachmentId).toBeUndefined();
		354	retryAttachmentUpload({ environmentId: firstEnvironment, image: file, draftTarget: draftId });
		355	await Promise.resolve();
		356	settled = awaitAttachmentUploads([file.id]);
		357	TestXmlHttpRequest.requests[1]!.complete();
		358	await settled;
		359	expect(store.getComposerDraft(draftId)?.files[0]).toMatchObject({
		360	uploadedAttachmentId: "pending-environment-1-question-retry.pdf",
		361	uploadEnvironmentId: firstEnvironment,
		362	});
		363	} finally {
		364	store.clearComposerContent(draftId);
		365	}
		366	});
		367
342	it("verifies an uploaded file reference before restoring it", async () => {	368	it("verifies an uploaded file reference before restoring it", async () => {
343	const file: ComposerFileAttachment = {	369	const file: ComposerFileAttachment = {
344	...makeFile("restored"),	370	...makeFile("restored"),

apps/web/src/pendingUserInput.test.ts+19

...	@@ -302,3 +302,22 @@ describe("pending user input question progress", () => {	...	@@ -302,3 +302,22 @@ describe("pending user input question progress", () => {
302	});	302	});
303	});	303	});
304	});	304	});
		305
		306	it("accepts attachment-only answers after every upload finishes", () => {
		307	const questions = [
		308	{ id: "spec", header: "Spec", question: "Provide a spec", options: [], multiSelect: false },
		309	];
		310	expect(buildPendingUserInputAnswers(questions, { spec: { attachmentCount: 1 } })).toEqual({
		311	spec: "",
		312	});
		313	expect(
		314	buildPendingUserInputAnswers(questions, {
		315	spec: { attachmentCount: 1, attachmentsBlocked: true },
		316	}),
		317	).toBeNull();
		318	expect(
		319	buildPendingUserInputAnswers([{ ...questions[0]!, allowCustomAnswer: false }], {
		320	spec: { attachmentCount: 1 },
		321	}),
		322	).toBeNull();
		323	});

apps/web/src/pendingUserInput.ts+12-2

 @@ -3,6 +3,8 @@ import type { UserInputQuestion } from "@t3tools/contracts";
 export interface PendingUserInputDraftAnswer {
   selectedOptionValues?: string[];
   customAnswer?: string;
+  attachmentCount?: number;
+  attachmentsBlocked?: boolean;
 }
 export interface PendingUserInputProgress {
 @@ -41,6 +43,7 @@ export function resolvePendingUserInputAnswer(
   question: UserInputQuestion,
   draft: PendingUserInputDraftAnswer | undefined,
 ): string | string[] | null {
+  if (draft?.attachmentsBlocked) return null;
   const customAnswer =
     question.allowCustomAnswer === false ? null : normalizeDraftAnswer(draft?.customAnswer);
   if (customAnswer) {
 @@ -51,10 +54,17 @@ export function resolvePendingUserInputAnswer(
     (value) => question.options.some((option) => (option.value ?? option.label) === value),
   );
   if (question.multiSelect) {
-    return selectedOptionValues.length > 0 ? selectedOptionValues : null;
+    return selectedOptionValues.length > 0
+      ? selectedOptionValues
+      : question.allowCustomAnswer !== false && (draft?.attachmentCount ?? 0) > 0
+        ? ""
+        : null;
   }
-  return selectedOptionValues[0] ?? null;
+  return (
+    selectedOptionValues[0] ??
+    (question.allowCustomAnswer !== false && (draft?.attachmentCount ?? 0) > 0 ? "" : null)
+  );
 }
 export function setPendingUserInputCustomAnswer(

apps/web/src/questionAttachments.test.ts created+100

...	@@ -0,0 +1,100 @@
1	import { ApprovalRequestId, EnvironmentId, ThreadId } from "@t3tools/contracts";
2	import { beforeEach, expect, it, vi } from "vite-plus/test";
3	import { useComposerDraftStore } from "./composerDraftStore";
4	import {
5	questionAttachmentDraftId,
6	questionAttachmentDraftPrefix,
7	changeQuestionAttachmentPreparation,
8	clearQuestionAttachmentDraft,
9	useQuestionAttachmentPreparation,
10	} from "./questionAttachments";
11
12	const release = vi.hoisted(() => vi.fn());
13	vi.mock("./lib/attachmentUploadQueue", () => ({ releaseDraftAttachments: release }));
14	const environmentId = EnvironmentId.make("environment-1");
15	const threadId = ThreadId.make("thread-1");
16	const requestId = ApprovalRequestId.make("request-1");
17	beforeEach(() => {
18	useComposerDraftStore.setState({ draftsByThreadKey: {}, draftThreadsByThreadKey: {} });
19	useQuestionAttachmentPreparation.setState({ counts: {} });
20	release.mockClear();
21	});
22	it("keeps question files separate from the normal draft and other questions", () => {
23	const revoke = vi.spyOn(URL, "revokeObjectURL");
24	const store = useComposerDraftStore.getState();
25	const first = questionAttachmentDraftId(environmentId, threadId, requestId, "first");
26	const second = questionAttachmentDraftId(environmentId, threadId, requestId, "second");
27	store.setPrompt({ environmentId, threadId }, "Unsent prompt");
28	const image = {
29	type: "image" as const,
30	id: "image-1",
31	name: "image.png",
32	mimeType: "image/png",
33	sizeBytes: 5,
34	previewUrl: "blob:question-image",
35	file: new File(["image"], "image.png", { type: "image/png" }),
36	};
37	store.addImages(first, [image]);
38	store.addFiles(second, [
39	{
40	type: "file",
41	id: "file-1",
42	name: "spec.txt",
43	mimeType: "text/plain",
44	sizeBytes: 4,
45	file: new File(["spec"], "spec.txt", { type: "text/plain" }),
46	},
47	]);
48	changeQuestionAttachmentPreparation(first, 1);
49	expect(store.getComposerDraft(first)?.images).toHaveLength(1);
50	expect(store.getComposerDraft(second)?.files).toHaveLength(1);
51	clearQuestionAttachmentDraft(first);
52	expect(store.getComposerDraft(first)).toBeNull();
53	expect(store.getComposerDraft(second)?.files).toHaveLength(1);
54	expect(store.getComposerDraft({ environmentId, threadId })?.prompt).toBe("Unsent prompt");
55	expect(useQuestionAttachmentPreparation.getState().counts[first]).toBeUndefined();
56	expect(release).toHaveBeenCalledWith([image]);
57	expect(revoke).toHaveBeenCalledWith(image.previewUrl);
58	revoke.mockRestore();
59	});
60	it("scopes provider request ids to their environment and thread", () => {
61	const keys = [
62	questionAttachmentDraftId(environmentId, threadId, requestId, "q"),
63	questionAttachmentDraftId(EnvironmentId.make("environment-2"), threadId, requestId, "q"),
64	questionAttachmentDraftId(environmentId, ThreadId.make("thread-2"), requestId, "q"),
65	];
66	expect(new Set(keys).size).toBe(3);
67	});
68	it("does not match drafts belonging to threads with a shared id prefix", () => {
69	const prefix = questionAttachmentDraftPrefix(environmentId, threadId);
70	expect(
71	questionAttachmentDraftId(environmentId, threadId, requestId, "q").startsWith(prefix),
72	).toBe(true);
73	for (const suffix of ["-extra", ":extra", "/extra", "%extra"]) {
74	expect(
75	questionAttachmentDraftId(
76	environmentId,
77	ThreadId.make(`${threadId}${suffix}`),
78	requestId,
79	"q",
80	).startsWith(prefix),
81	).toBe(false);
82	}
83	});
84
85	it("does not clear another environment whose id contains a question prefix", () => {
86	const otherEnvironment = EnvironmentId.make(
87	`${environmentId}:question-${encodeURIComponent(JSON.stringify(threadId))}-nested`,
88	);
89	const otherKey = questionAttachmentDraftId(otherEnvironment, threadId, requestId, "q");
90	const ownKey = questionAttachmentDraftId(environmentId, threadId, requestId, "q");
91	const store = useComposerDraftStore.getState();
92	store.setPrompt(otherKey, "Keep this answer");
93	store.setPrompt(ownKey, "Discard this answer");
94	const prefix = questionAttachmentDraftPrefix(environmentId, threadId);
95	for (const key of [ownKey, otherKey]) {
96	if (key.startsWith(prefix)) clearQuestionAttachmentDraft(key);
97	}
98	expect(store.getComposerDraft(ownKey)).toBeNull();
99	expect(store.getComposerDraft(otherKey)?.prompt).toBe("Keep this answer");
100	});

apps/web/src/questionAttachments.ts created+53

...	@@ -0,0 +1,53 @@
1	import type { ApprovalRequestId, EnvironmentId, ThreadId } from "@t3tools/contracts";
2	import { create } from "zustand";
3	import { DraftId, useComposerDraftStore } from "./composerDraftStore";
4	import { releaseDraftAttachments } from "./lib/attachmentUploadQueue";
5
6	export function questionAttachmentDraftPrefix(
7	environmentId: EnvironmentId,
8	threadId: ThreadId,
9	): string {
10	return `${encodeURIComponent(JSON.stringify(environmentId))}:question-${encodeURIComponent(JSON.stringify(threadId))}-`;
11	}
12
13	export function questionAttachmentDraftId(
14	environmentId: EnvironmentId,
15	threadId: ThreadId,
16	requestId: ApprovalRequestId,
17	questionId: string,
18	): DraftId {
19	return DraftId.make(
20	`${questionAttachmentDraftPrefix(environmentId, threadId)}${encodeURIComponent(JSON.stringify([requestId, questionId]))}`,
21	);
22	}
23
24	export const useQuestionAttachmentPreparation = create<{ counts: Record<string, number> }>(() => ({
25	counts: {},
26	}));
27
28	export function changeQuestionAttachmentPreparation(key: DraftId, delta: number): void {
29	useQuestionAttachmentPreparation.setState((state) =>
30	delta < 0 && !(key in state.counts)
31	? state
32	: {
33	counts: { ...state.counts, [key]: Math.max(0, (state.counts[key] ?? 0) + delta) },
34	},
35	);
36	}
37
38	export function clearQuestionAttachmentDraft(key: DraftId): void {
39	const store = useComposerDraftStore.getState();
40	const draft = store.getComposerDraft(key);
41	if (draft) {
42	releaseDraftAttachments([...draft.images, ...draft.files]);
43	for (const image of draft.images) {
44	if (image.previewUrl.startsWith("blob:")) URL.revokeObjectURL(image.previewUrl);
45	}
46	}
47	store.clearComposerContent(key);
48	useQuestionAttachmentPreparation.setState(({ counts }) => {
49	const next = { ...counts };
50	delete next[key];
51	return { counts: next };
52	});
53	}

apps/web/src/session-logic.ts+9

...	@@ -2,7 +2,9 @@ import {	...	@@ -2,7 +2,9 @@ import {
2	requestKindFromRequestType,	2	requestKindFromRequestType,
3	type PendingApproval,	3	type PendingApproval,
4	} from "@t3tools/client-runtime/pending-requests";	4	} from "@t3tools/client-runtime/pending-requests";
		5	import { UserInputAttachmentAnswerPayload } from "@t3tools/contracts";
5	import * as Option from "effect/Option";	6	import * as Option from "effect/Option";
		7	import * as Schema from "effect/Schema";
6	import * as Arr from "effect/Array";	8	import * as Arr from "effect/Array";
7	import { shallow } from "zustand/vanilla/shallow";	9	import { shallow } from "zustand/vanilla/shallow";
8	import { isBackgroundTaskActivity } from "@t3tools/client-runtime/state/subagentRuntime";	10	import { isBackgroundTaskActivity } from "@t3tools/client-runtime/state/subagentRuntime";
...	@@ -51,6 +53,7 @@ export {	...	@@ -51,6 +53,7 @@ export {
51	} from "@t3tools/client-runtime/work-log/presentation";	53	} from "@t3tools/client-runtime/work-log/presentation";
52		54
53	export interface WorkLogEntry {	55	export interface WorkLogEntry {
		56	questionAnswer?: UserInputAttachmentAnswerPayload;
54	id: string;	57	id: string;
55	createdAt: string;	58	createdAt: string;
56	turnId?: TurnId \| null;	59	turnId?: TurnId \| null;
...	@@ -492,6 +495,8 @@ function isPlanBoundaryToolActivity(activity: OrchestrationThreadActivity): bool	...	@@ -492,6 +495,8 @@ function isPlanBoundaryToolActivity(activity: OrchestrationThreadActivity): bool
492	return typeof payload?.detail === "string" && payload.detail.startsWith("ExitPlanMode:");	495	return typeof payload?.detail === "string" && payload.detail.startsWith("ExitPlanMode:");
493	}	496	}
494		497
		498	const decodeQuestionAttachmentAnswer = Schema.decodeUnknownOption(UserInputAttachmentAnswerPayload);
		499
495	function toDerivedWorkLogEntry(activity: OrchestrationThreadActivity): DerivedWorkLogEntry {	500	function toDerivedWorkLogEntry(activity: OrchestrationThreadActivity): DerivedWorkLogEntry {
496	const cachedEntry = derivedWorkLogEntryByActivity.get(activity);	501	const cachedEntry = derivedWorkLogEntryByActivity.get(activity);
497	if (cachedEntry) {	502	if (cachedEntry) {
...	@@ -543,6 +548,10 @@ function toDerivedWorkLogEntry(activity: OrchestrationThreadActivity): DerivedWo	...	@@ -543,6 +548,10 @@ function toDerivedWorkLogEntry(activity: OrchestrationThreadActivity): DerivedWo
543	: activity.tone,	548	: activity.tone,
544	sourceActivityKind: activity.kind,	549	sourceActivityKind: activity.kind,
545	};	550	};
		551	if (activity.kind === "user-input.answer-submitted") {
		552	const answer = decodeQuestionAttachmentAnswer(payload);
		553	if (Option.isSome(answer)) entry.questionAnswer = answer.value;
		554	}
546	const itemType = extractWorkLogItemType(payload);	555	const itemType = extractWorkLogItemType(payload);
547	const requestKind = extractWorkLogRequestKind(payload);	556	const requestKind = extractWorkLogRequestKind(payload);
548	const viewedImagePath = asTrimmedString(asRecord(payload?.data)?.imagePath);	557	const viewedImagePath = asTrimmedString(asRecord(payload?.data)?.imagePath);

docs/user/question-attachments.md created+9

...	@@ -0,0 +1,9 @@
1	# Files in question answers
2
3	When an agent asks a question that accepts a custom answer, use Attach files or paste an image into the answer field. On mobile, use the attachment button to choose photos or files. You can send a file by itself, with a selected option, or with a typed answer.
4
5	Each question keeps its own attachments as you move between questions. Your normal prompt draft stays separate. Wait for uploads to finish before submitting; retry or remove any failed upload. A failed response keeps the draft available to try again.
6
7	Files upload to the environment running the thread, including remote environments. The agent receives paths to those saved files with your answer and can open them with its available tools. Questions that only accept predefined choices do not offer attachments. Older servers need updating before this option appears.
8
9	Submitted attachments remain in the thread history. Reverting a thread removes attachments belonging to discarded answers; deleting the thread uses the same file cleanup as other attachments. You can attach up to eight files across one set of answers, using the same file size limits as the normal composer.

packages/contracts/src/environment.ts+2

...	@@ -80,6 +80,8 @@ export const ExecutionEnvironmentCapabilities = Schema.Struct({	...	@@ -80,6 +80,8 @@ export const ExecutionEnvironmentCapabilities = Schema.Struct({
80	connectionProbe: Schema.optionalKey(Schema.Boolean),	80	connectionProbe: Schema.optionalKey(Schema.Boolean),
81	/** Missing on older servers, which still accept inline image attachments. */	81	/** Missing on older servers, which still accept inline image attachments. */
82	attachmentUploads: Schema.optionalKey(Schema.Boolean),	82	attachmentUploads: Schema.optionalKey(Schema.Boolean),
		83	/** Uploaded files may accompany question answers. */
		84	questionAttachments: Schema.optionalKey(Schema.Boolean),
83	/** Missing on servers that only accept image attachments. */	85	/** Missing on servers that only accept image attachments. */
84	fileAttachments: Schema.optionalKey(	86	fileAttachments: Schema.optionalKey(
85	Schema.Struct({	87	Schema.Struct({

packages/contracts/src/orchestration.ts+18

...	@@ -354,6 +354,22 @@ export const ChatAttachment = Schema.Union([	...	@@ -354,6 +354,22 @@ export const ChatAttachment = Schema.Union([
354	ChatUnknownAttachment,	354	ChatUnknownAttachment,
355	]);	355	]);
356	export type ChatAttachment = typeof ChatAttachment.Type;	356	export type ChatAttachment = typeof ChatAttachment.Type;
		357
		358	export const UserInputAttachments = Schema.Record(
		359	Schema.String,
		360	Schema.Array(Schema.Union([ChatImageAttachment, ChatFileAttachment])).pipe(
		361	Schema.check(Schema.isMaxLength(PROVIDER_SEND_TURN_MAX_ATTACHMENTS)),
		362	),
		363	);
		364	export type UserInputAttachments = typeof UserInputAttachments.Type;
		365
		366	export const UserInputAttachmentAnswerPayload = Schema.Struct({
		367	requestId: ApprovalRequestId,
		368	questionTextById: Schema.optional(Schema.Record(Schema.String, Schema.String)),
		369	answers: ProviderUserInputAnswers,
		370	attachmentsByQuestionId: UserInputAttachments,
		371	});
		372	export type UserInputAttachmentAnswerPayload = typeof UserInputAttachmentAnswerPayload.Type;
357	const UploadChatAttachment = Schema.Union([UploadChatImageAttachment]);	373	const UploadChatAttachment = Schema.Union([UploadChatImageAttachment]);
358	export type UploadChatAttachment = typeof UploadChatAttachment.Type;	374	export type UploadChatAttachment = typeof UploadChatAttachment.Type;
359		375
...	@@ -1139,6 +1155,7 @@ const ThreadUserInputRespondCommand = Schema.Struct({	...	@@ -1139,6 +1155,7 @@ const ThreadUserInputRespondCommand = Schema.Struct({
1139	threadId: ThreadId,	1155	threadId: ThreadId,
1140	requestId: ApprovalRequestId,	1156	requestId: ApprovalRequestId,
1141	answers: ProviderUserInputAnswers,	1157	answers: ProviderUserInputAnswers,
		1158	attachmentsByQuestionId: Schema.optional(UserInputAttachments),
1142	createdAt: IsoDateTime,	1159	createdAt: IsoDateTime,
1143	});	1160	});
1144		1161
...	@@ -1585,6 +1602,7 @@ const ThreadUserInputResponseRequestedPayload = Schema.Struct({	...	@@ -1585,6 +1602,7 @@ const ThreadUserInputResponseRequestedPayload = Schema.Struct({
1585	threadId: ThreadId,	1602	threadId: ThreadId,
1586	requestId: ApprovalRequestId,	1603	requestId: ApprovalRequestId,
1587	answers: ProviderUserInputAnswers,	1604	answers: ProviderUserInputAnswers,
		1605	attachmentsByQuestionId: Schema.optional(UserInputAttachments),
1588	createdAt: IsoDateTime,	1606	createdAt: IsoDateTime,
1589	});	1607	});
1590		1608

packages/contracts/src/provider.ts+2

...	@@ -19,6 +19,7 @@ import {	...	@@ -19,6 +19,7 @@ import {
19	ProviderRequestKind,	19	ProviderRequestKind,
20	ProviderSandboxMode,	20	ProviderSandboxMode,
21	ProviderUserInputAnswers,	21	ProviderUserInputAnswers,
		22	UserInputAttachments,
22	RuntimeMode,	23	RuntimeMode,
23	} from "./orchestration.ts";	24	} from "./orchestration.ts";
24	import { ProviderInstanceId, ProviderDriverKind } from "./providerInstance.ts";	25	import { ProviderInstanceId, ProviderDriverKind } from "./providerInstance.ts";
...	@@ -110,6 +111,7 @@ export const ProviderRespondToUserInputInput = Schema.Struct({	...	@@ -110,6 +111,7 @@ export const ProviderRespondToUserInputInput = Schema.Struct({
110	threadId: ThreadId,	111	threadId: ThreadId,
111	requestId: ApprovalRequestId,	112	requestId: ApprovalRequestId,
112	answers: ProviderUserInputAnswers,	113	answers: ProviderUserInputAnswers,
		114	attachmentsByQuestionId: Schema.optional(UserInputAttachments),
113	});	115	});
114	export type ProviderRespondToUserInputInput = typeof ProviderRespondToUserInputInput.Type;	116	export type ProviderRespondToUserInputInput = typeof ProviderRespondToUserInputInput.Type;
115		117

pnpm-lock.yaml+3

 @@ -473,6 +473,9 @@ importers:
       '@types/react':
         specifier: ~19.2.0
         version: 19.2.16
+      '@types/react-dom':
+        specifier: ~19.2.3
+        version: 19.2.3(@types/react@19.2.16)
       babel-preset-expo:
         specifier: ~57.0.9
         version: 57.0.9(@babel/core@7.29.7)(@babel/runtime@7.29.7)(expo-widgets@57.0.15)(expo@57.0.18)(react-refresh@0.14.2)

author	shivam <91240327+shivamhwp@users.noreply.github.com> 2026-09-08 12:13:38+05:30
committer	GitHub <noreply@github.com> 2026-09-08 12:13:38+05:30
log	7220dfe2c949476eaa7d21eccbcd3a0ce0eddb49
tree	ec8f6c6fba758f61a36606fa123b53837d4edd84
parent	349ce3014233352e073a5fc1b3f12bd786160913
signature	Signed by PGP key B5690EEEBB952194

feat(chat): attach files to question answers (#9871)