@vercel/factory 0.0.17 → 0.0.18

package/dist/api.mjs

@@ -1,24 +1,26 @@
+import { collectFactoryRecords } from "./store/iterate.mjs";
 import { repositoryIdSchema, signalIdSchema, taskIdSchema } from "./schema/id.mjs";
 import { repositorySlugSchema } from "./schema/repository.mjs";
 import { parseAgentRouteBinding } from "./schema/agent-route.mjs";
 import { taskStateSchema } from "./schema/task.mjs";
+import { RecordNotFoundError, VersionConflictError } from "./store/driver.mjs";
 import { InvalidTransitionError } from "./schema/transitions.mjs";
-import { readEvents } from "./client-events.mjs";
 import { MAX_IMAGE_BYTES, imageIdSchema, imagePartFilename, imageUploadSchema } from "./image-input.mjs";
 import { Transcript } from "./client-transcript.mjs";
 import { routeTaskWork } from "./agent-routes.mjs";
-import { RecordNotFoundError, VersionConflictError } from "./store/driver.mjs";
 import { BudgetExhaustedError, DispatchRefusedError, dispatchTask } from "./dispatch.mjs";
+import { findingSchema } from "./schema/finding.mjs";
 import { ApprovalAccessError, createApprovalAccess } from "./approval-access.mjs";
 import { agentSessionIdSchema, agentSessionSchema } from "./schema/session.mjs";
 import { ApprovalError, ImageInputError, SessionConflictError } from "./store/engine.mjs";
+import { InvalidStoreQueryError } from "./store/indexed.mjs";
+import { answerSessionQuestionRequestSchema, apiAgentSchema, controlSessionRequestSchema, createSessionRequestSchema, repositoryDetailsSchema, repositorySummarySchema, sendSessionMessageRequestSchema, sessionInputResponseSchema, sessionPageSchema, sessionPullRequestSchema, sessionPullRequestStateSchema, sessionViewSchema, sessionWorkGroupSchema, sessionWorkResultSchema, sessionWorkTaskSchema, submitSessionInputRequestSchema } from "./api-contracts.mjs";
 import { inboxActivityItemSchema, inboxActivitySchema } from "./inbox-activity.mjs";
 import { agentModelConfigSchema, modelSettingsSchema, updateModelDefaultsSchema } from "./model-settings.mjs";
 import { sessionPreviewSchema, sessionPreviewsSchema } from "./session-previews.mjs";
 import { sessionReviewCheckSchema, sessionReviewIssueSchema, sessionReviewSchema, sessionReviewScreenshotSchema } from "./session-review.mjs";
 import { workspaceFileContentSchema, workspaceFileEntrySchema, workspaceFilesRequestSchema, workspaceFilesSchema, workspacePathSchema } from "./workspace-files.mjs";
 import { intakeViewSchema, retryIntakeSchema } from "./intake-contracts.mjs";
-import { answerSessionQuestionRequestSchema, apiAgentSchema, controlSessionRequestSchema, createSessionRequestSchema, repositoryDetailsSchema, repositorySummarySchema, sendSessionMessageRequestSchema, sessionInputResponseSchema, sessionPageSchema, sessionViewSchema, submitSessionInputRequestSchema } from "./api-contracts.mjs";
 import { unavailableWorkspaceDiff, workspaceDiffFileSchema, workspaceDiffSchema } from "./workspace-diff.mjs";
 import { taskGraphViewSchema } from "./task-graph-view.mjs";
 import { workspaceGitFilesScript } from "./workspace-files-git.mjs";
@@ -39,14 +41,18 @@ const json = (value, status = 200) => Response.json(value, {
 	status,
 	headers: { "cache-control": "no-store" }
 });
-function attention(task, change) {
-	if (task?.state === "needs_human") return "question";
-	if (task?.state === "failed" || task?.state === "stalled") return task.state;
-	if (change?.state === "ready") return "review";
-}
+const pullRequestStatusObservationSchema = z.strictObject({
+	changeId: sessionPullRequestSchema.shape.changeId,
+	state: sessionPullRequestStateSchema.nullable(),
+	sync: sessionPullRequestSchema.shape.sync,
+	checkedAt: sessionPullRequestSchema.shape.checkedAt,
+	observedAt: sessionPullRequestSchema.shape.observedAt,
+	syncMessage: sessionPullRequestSchema.shape.syncMessage
+});
 /** Creates the authenticated request handler for the public Factory HTTP API. */
 function createFactoryApi(options) {
 	const { stores } = options;
+	const maxSessionPullRequests = z.number().int().min(1).max(100).parse(options.maxSessionPullRequests ?? 50);
 	const agents = options.agents.map((agent) => apiAgentSchema.parse(agent));
 	const agentModels = (options.agentModels ?? []).map((entry) => agentModelConfigSchema.parse(entry));
 	if (new Set(agentModels.map((entry) => entry.agent)).size !== agentModels.length) throw new Error("Duplicate agent model catalog");
@@ -59,64 +65,64 @@ function createFactoryApi(options) {
 	if (new Set(agents.map((agent) => agent.id)).size !== agents.length) throw new Error("Duplicate API agent");
 	if (options.continuationAgent !== void 0 && !agents.some((agent) => agent.id === options.continuationAgent && agent.route === void 0 && agent.canStart)) throw new Error("continuationAgent must be a directly startable conversation agent");
 	for (const agent of agents) if (agent.route !== void 0 && options.routes.get(agent.route)?.agent !== agent.id) throw new Error(`API agent ${agent.id} must select one of its registered routes`);
+	async function configuredRepositories() {
+		return mapConcurrent(options.repositories, async (slug) => {
+			return (await stores.repositories.list({
+				limit: 1,
+				match: { slug }
+			})).items[0] ?? options.ensureRepository(slug);
+		});
+	}
 	const approvals = createApprovalAccess({
 		stores,
 		operators: options.operators ?? [],
 		repositories: options.repositories
 	});
-	const approvalView = approvals.view;
 	async function approvalPage(url, actor) {
 		const input = z.object({
 			status: z.enum([
 				"pending",
 				"decided",
 				"all"
-			]).default("pending").describe("Pending approvals, recorded decisions, or both."),
-			repository: repositorySlugSchema.optional().describe("Configured repository slug to filter."),
-			query: z.string().trim().max(200).optional().describe("Case-insensitive text in the finding, repository, Task ID, or decision actor/reason."),
+			]).default("pending"),
+			repository: repositorySlugSchema.optional(),
+			query: z.string().trim().max(200).optional(),
 			sort: z.enum([
 				"created",
 				"priority",
 				"decided"
-			]).default("created").describe("Oldest creation first, highest finding priority first, or newest decision first; ties use creation time and Task ID."),
-			limit: z.coerce.number().int().min(1).max(100).default(30).describe("Maximum authorized approvals per page."),
-			cursor: taskIdSchema.optional().describe("Last Task ID from the previous page with the same filters.")
+			]).default("created"),
+			limit: z.coerce.number().int().min(1).max(100).default(30),
+			cursor: z.string().max(8192).optional()
 		}).parse(Object.fromEntries(url.searchParams));
-		if (input.repository && !options.repositories.includes(input.repository)) throw new ApiError(403, "Repository is not configured");
-		const repos = (await stores.repositories.list()).filter((repo) => repo.enabled && options.repositories.includes(repo.slug));
-		const ids = new Set(repos.map((repo) => repo.id));
-		const selected = input.repository ? repos.find((repo) => repo.slug === input.repository)?.id : void 0;
-		const tasks = (await stores.tasks.list()).filter((task) => task.approval !== void 0 && task.repositoryIds.length > 0 && task.repositoryIds.every((id) => ids.has(id)) && (!input.repository || selected && task.repositoryIds.includes(selected)) && (input.status === "all" || (input.status === "pending" ? task.approval === "required" && task.state === "queued" : task.approval !== "required"))).sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
-		let views;
-		if (input.query || input.sort !== "created") {
-			views = await mapConcurrent(tasks, approvalView);
-			const query = input.query?.toLowerCase();
-			if (query) views = views.filter((view) => [
-				view.task.id,
-				...view.repositories,
-				view.finding?.title,
-				view.finding?.body,
-				view.finding?.category,
-				view.finding?.path,
-				view.decision?.decidedBy,
-				view.decision?.reason
-			].filter(Boolean).join(" ").toLowerCase().includes(query));
-			if (input.sort === "priority") views.sort((a, b) => (a.finding?.priority ?? "P4").localeCompare(b.finding?.priority ?? "P4") || a.task.createdAt.localeCompare(b.task.createdAt) || a.task.id.localeCompare(b.task.id));
-			if (input.sort === "decided") views.sort((a, b) => (b.decision?.recordedAt ?? b.task.createdAt).localeCompare(a.decision?.recordedAt ?? a.task.createdAt) || a.task.createdAt.localeCompare(b.task.createdAt) || a.task.id.localeCompare(b.task.id));
-		}
-		const ordered = views?.map((view) => view.task) ?? tasks;
-		const start = input.cursor ? ordered.findIndex((task) => task.id === input.cursor) + 1 : 0;
-		if (input.cursor && start === 0) throw new ApiError(409, "Approval list changed; refresh from the first page");
-		const page = ordered.slice(start, start + input.limit);
+		const repos = (await configuredRepositories()).filter((repo) => repo.enabled);
+		const selected = input.repository ? repos.find((repo) => repo.slug === input.repository) : void 0;
+		if (input.repository && !selected) throw new ApiError(403, "Repository is not configured");
+		const page = await stores.approvals.list({
+			limit: input.limit,
+			cursor: input.cursor,
+			sort: input.sort,
+			search: input.query || void 0,
+			includeTotal: true,
+			match: {
+				...selected ? { repositoryIds: [selected.id] } : {},
+				...input.status === "all" ? {} : { status: input.status }
+			},
+			fields: [{
+				path: ["repositoryIds"],
+				test: "subset",
+				value: repos.map((repo) => repo.id)
+			}]
+		});
 		return json({
 			actor,
-			items: views ? views.slice(start, start + input.limit) : await mapConcurrent(page, approvalView),
-			totalCount: ordered.length,
-			nextCursor: start + input.limit < ordered.length ? page.at(-1).id : null
+			items: await mapConcurrent(page.items, (id) => approvals.get(actor, id)),
+			nextCursor: page.nextCursor,
+			totalCount: page.totalCount
 		});
 	}
 	async function start(session, task, message, operationId) {
-		const continuation = task ? (await stores.sessions.get(session.id))?.continuations?.find((item) => item.taskId === task.id) : void 0;
+		const continuation = task ? await stores.sessions.getContinuation(session.id, task.id) : void 0;
 		const attachments = continuation ? continuation.contextAttachments ?? continuation.attachments : session.attachments;
 		return options.start({
 			session,
@@ -130,14 +136,109 @@ function createFactoryApi(options) {
 		const binding = task.work.route;
 		return binding ? options.routes.get(binding) : void 0;
 	}
-	function taskAgent(session, task) {
+	async function taskAgent(session, task) {
 		const route = taskRoute(task);
 		if (route) return agents.some((agent) => agent.id === route.agent) ? route.agent : void 0;
-		const continuation = session.continuations?.find((item) => item.taskId === task.id);
+		const continuation = await stores.sessions.getContinuation(session.id, task.id);
 		return task.work.route?.id === "conversation" && task.work.route.version === 1 && continuation?.agent === options.continuationAgent ? options.continuationAgent : void 0;
 	}
-	function executionSession(session, task, agent) {
-		const activeAgent = agent ?? (task ? taskAgent(session, task) : session.agent);
+	const terminalWorkStates = /* @__PURE__ */ new Set([
+		"succeeded",
+		"failed",
+		"cancelled"
+	]);
+	function aggregateWorkState(tasks, root) {
+		const states = new Set(tasks.map((task) => task.state));
+		for (const state of [
+			"needs_human",
+			"verifying",
+			"running",
+			"queued",
+			"stalled"
+		]) if (states.has(state)) return state;
+		if (root && terminalWorkStates.has(root.state)) return root.state;
+		for (const state of [
+			"failed",
+			"cancelled",
+			"succeeded"
+		]) if (states.has(state)) return state;
+		return "queued";
+	}
+	async function sessionWorkGroups(session, selectedTask, relatedTasks, pullRequests) {
+		const knownTasks = /* @__PURE__ */ new Map();
+		for (const task of relatedTasks) knownTasks.set(task.id, task);
+		if (selectedTask) knownTasks.set(selectedTask.id, selectedTask);
+		async function ancestor(id) {
+			const cached = knownTasks.get(id);
+			if (cached) return cached;
+			const fetched = await stores.tasks.get(id);
+			if (fetched) knownTasks.set(id, fetched);
+			return fetched;
+		}
+		async function requestRootId(task) {
+			let current = task;
+			const visited = /* @__PURE__ */ new Set([task.id]);
+			for (;;) {
+				if (current.parentTaskId === void 0 || visited.has(current.parentTaskId)) return current.id;
+				const parent = await ancestor(current.parentTaskId);
+				if (!parent || parent.work.route?.id === "conversation") return current.id;
+				visited.add(parent.id);
+				current = parent;
+			}
+		}
+		const tasks = [...new Map([...relatedTasks, ...selectedTask ? [selectedTask] : []].filter((task) => task.work.route?.id !== "conversation").map((task) => [task.id, task])).values()];
+		const grouped = /* @__PURE__ */ new Map();
+		for (const task of tasks) {
+			if (!task.work.route) continue;
+			const requestId = await requestRootId(task);
+			const group = grouped.get(requestId) ?? [];
+			group.push(task);
+			grouped.set(requestId, group);
+		}
+		return await mapConcurrent([...grouped], async ([requestId, groupedTasks]) => {
+			let root = groupedTasks.find((task) => task.id === requestId) ?? null;
+			if (!root) {
+				const candidate = await ancestor(requestId);
+				root = candidate ? await authorizedRelatedTask(session, candidate) : null;
+				if (root && root.work.route?.id === "conversation") root = null;
+			}
+			const orderedTasks = [...root ? [root] : [], ...groupedTasks.filter((task) => task.id !== root?.id)];
+			const anchor = root ?? orderedTasks[0];
+			const changeIds = [...new Set(orderedTasks.map((task) => task.changeId).filter((value) => value !== void 0))];
+			const state = aggregateWorkState(orderedTasks, root);
+			let result;
+			if (root && options.presentSessionWork && orderedTasks.every((task) => terminalWorkStates.has(task.state))) try {
+				const presented = await options.presentSessionWork({
+					root,
+					tasks: orderedTasks,
+					pullRequests: pullRequests.filter((pullRequest) => changeIds.includes(pullRequest.changeId))
+				});
+				if (presented) result = sessionWorkResultSchema.parse(presented);
+			} catch (error) {
+				options.reportError?.(error, {
+					method: "GET",
+					path: "session-work-presentation"
+				});
+			}
+			return sessionWorkGroupSchema.parse({
+				requestId,
+				title: anchor.work.title,
+				agent: taskRoute(anchor)?.agent ?? anchor.work.route?.id ?? "Workflow",
+				state,
+				tasks: orderedTasks.map((task) => ({
+					taskId: task.id,
+					title: task.work.title,
+					agent: taskRoute(task)?.agent ?? task.work.route?.id ?? "Workflow",
+					state: task.state,
+					attempt: task.attempt
+				})),
+				changeIds,
+				result
+			});
+		});
+	}
+	async function executionSession(session, task, agent) {
+		const activeAgent = agent ?? (task ? await taskAgent(session, task) : session.agent);
 		if (!activeAgent) throw new ApiError(409, "Task has no configured agent route");
 		return agentSessionSchema.parse({
 			...session,
@@ -147,282 +248,369 @@ function createFactoryApi(options) {
 			external: task ? void 0 : session.external
 		});
 	}
-	function sessionTasks(session, byId, candidates = byId.values()) {
-		const root = session.taskId === void 0 ? null : byId.get(session.taskId) ?? null;
-		function depth(task) {
-			const seen = /* @__PURE__ */ new Set();
-			let current = task;
-			while (current?.parentTaskId && !seen.has(current.id)) {
-				seen.add(current.id);
-				current = byId.get(current.parentTaskId);
-			}
-			return seen.size;
-		}
-		if (root === null) return {
-			root,
-			relatedTasks: [],
-			tasks: []
-		};
-		const relatedTasks = [...candidates].filter((task) => root !== null && task.id !== root.id && task.replyTo.channel === "api" && task.replyTo.address === session.id && task.repositoryIds.length === 1 && task.repositoryIds[0] === session.repositoryId && (task.work.route !== void 0 || session.continuations?.some((item) => item.taskId === task.id))).sort((a, b) => a.createdAt.localeCompare(b.createdAt) || depth(a) - depth(b) || a.id.localeCompare(b.id));
+	function workflowTasks(session, tasks) {
+		return [...tasks].filter((task) => task.work.route === void 0 && !task.question && task.replyTo.channel === "api" && task.replyTo.address === session.id && task.repositoryIds.length === 1 && task.repositoryIds[0] === session.repositoryId);
+	}
+	async function mayAccessTask(owner, task) {
+		return options.canAccessTask ? options.canAccessTask({ id: owner }, task) : options.sharedWorkspaceOwner === owner;
+	}
+	async function sessionFinding(session, task) {
+		if (!task?.origin.signalId) return null;
+		const repositoryIds = session.external?.repositoryIds ?? (session.repositoryId ? [session.repositoryId] : []);
+		if (!task.repositoryIds.every((id) => repositoryIds.includes(id)) || (session.attached || session.external) && !await mayAccessTask(session.owner, task)) return null;
+		const signal = await stores.signals.get(task.origin.signalId);
+		if (!signal || !task.repositoryIds.includes(signal.repositoryId)) return null;
+		const finding = findingSchema.safeParse(signal.payload);
+		return finding.success ? finding.data : null;
+	}
+	async function findingSummary(summary) {
+		if (!summary.task?.approval) return summary;
+		const task = await stores.tasks.get(summary.task.id);
+		const finding = await sessionFinding(summary.session, task);
 		return {
-			root,
-			relatedTasks,
-			tasks: [...root ? [root] : [], ...relatedTasks]
+			...summary,
+			finding: finding ? {
+				priority: finding.priority,
+				category: finding.category
+			} : null
 		};
 	}
-	function conversationQuestion(tasks, byId) {
-		for (const parent of tasks) {
-			const question = parent.questionTaskId ? byId.get(parent.questionTaskId) : void 0;
-			if (parent.state === "needs_human" && question?.state === "needs_human" && question.question && question.parentTaskId === parent.id && question.parentTaskAttempt === parent.attempt && question.replyTo.channel === parent.replyTo.channel && question.replyTo.address === parent.replyTo.address) return question;
+	async function authorizedSummary(summary, owner) {
+		const { session } = summary;
+		if (!agents.some((agent) => agent.id === session.agent)) return null;
+		if (session.attached) {
+			const root = session.taskId ? await stores.tasks.get(session.taskId) : null;
+			if (!root || !await mayAccessTask(owner, root)) return null;
+		}
+		if (summary.task && (session.attached || session.external) && options.canAccessTask) {
+			const selected = await stores.tasks.get(summary.task.id);
+			if (!selected || !await mayAccessTask(owner, selected)) return null;
 		}
-		return null;
+		let question = summary.question;
+		if (question && session.external) {
+			const task = await stores.tasks.get(question.id);
+			const parent = task?.parentTaskId ? await stores.tasks.get(task.parentTaskId) : null;
+			if (!task || !parent || !await mayAccessTask(owner, task) || !await mayAccessTask(owner, parent)) question = null;
+		}
+		const route = summary.task?.work.route ? options.routes.get(summary.task.work.route) : void 0;
+		const candidate = summary.task ? route?.agent ?? (summary.task.work.route?.id === "conversation" && summary.task.work.route.version === 1 ? options.continuationAgent : void 0) : session.agent;
+		const activeAgent = agents.some((agent) => agent.id === candidate) && (!summary.task || summary.activeAgent === candidate) ? candidate : void 0;
+		let attention = summary.attention;
+		if (summary.question && !question) {
+			const head = summary.execution ? await stores.transcripts.head(summary.execution) : null;
+			attention = head?.state === "failed" ? "failed" : session.external && (head?.state === "waiting" || head?.state === "needs input") ? "conversation" : void 0;
+		}
+		return {
+			...summary,
+			question,
+			attention,
+			activeAgent,
+			execution: activeAgent ? summary.execution : null
+		};
 	}
-	function workflowTasks(session, tasks) {
-		return [...tasks].filter((task) => task.work.route === void 0 && !task.question && task.replyTo.channel === "api" && task.replyTo.address === session.id && task.repositoryIds.length === 1 && task.repositoryIds[0] === session.repositoryId);
+	function relatedQuery(session) {
+		return {
+			match: { replyTo: session.external?.replyTo ?? {
+				channel: "api",
+				address: session.id
+			} },
+			...!session.external ? { fields: [
+				{
+					path: ["repositoryIds"],
+					test: "eq",
+					value: session.repositoryId ? [session.repositoryId] : []
+				},
+				{
+					path: ["work", "route"],
+					test: "exists"
+				},
+				...session.taskId ? [{
+					path: ["id"],
+					test: "ne",
+					value: session.taskId
+				}] : []
+			] } : {}
+		};
 	}
-	function workflowAttention(session, tasks) {
-		const work = workflowTasks(session, tasks);
-		if (work.some((task) => task.state === "failed")) return "failed";
-		if (work.some((task) => task.state === "stalled")) return "stalled";
+	async function authorizedRelatedTask(session, task) {
+		if (session.external && (!task.repositoryIds.every((id) => session.external.repositoryIds.includes(id)) || !await mayAccessTask(session.owner, task))) return null;
+		if (!session.external && (task.repositoryIds.length !== 1 || task.repositoryIds[0] !== session.repositoryId)) return null;
+		return task;
 	}
-	async function view(session, snapshot, detail = "full") {
-		if (session.external) {
-			const external = session.external;
-			const relatedTasks = (await mapConcurrent((options.canAccessTask ? snapshot ? [...snapshot.tasks.values()] : await stores.tasks.forReplyTo(external.replyTo) : []).filter((task) => task.replyTo.channel === external.replyTo.channel && task.replyTo.address === external.replyTo.address && task.repositoryIds.every((id) => external.repositoryIds.includes(id))), async (task) => await options.canAccessTask?.({ id: session.owner }, task) ? task : null)).filter((task) => task !== null).sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
-			const question = conversationQuestion(relatedTasks, new Map(relatedTasks.map((task) => [task.id, task])));
-			const transcript = session.execution ? await stores.transcripts.get(session.execution) : null;
-			const humanAttention = question ? "question" : transcript?.state === "failed" ? "failed" : transcript?.state === "waiting" || transcript?.state === "needs input" ? "conversation" : void 0;
+	async function sessionPullRequests(session, selectedTask, signal) {
+		const maxRelatedTaskPages = 10;
+		const changeIds = /* @__PURE__ */ new Set();
+		const addTask = (task) => {
+			if (task?.changeId) changeIds.add(task.changeId);
+		};
+		addTask(selectedTask);
+		if (session.changeId) changeIds.add(session.changeId);
+		if (session.taskId && selectedTask?.id !== session.taskId) {
+			const root = await stores.tasks.get(session.taskId);
+			if (root) addTask(await authorizedRelatedTask(session, root));
+		}
+		let cursor;
+		let pages = 0;
+		let truncated = changeIds.size > maxSessionPullRequests;
+		let limitReached = false;
+		do {
+			pages += 1;
+			const page = await stores.tasks.list({
+				limit: 100,
+				cursor,
+				...relatedQuery(session)
+			});
+			const tasks = await mapConcurrent(page.items, (task) => authorizedRelatedTask(session, task));
+			for (const task of tasks) {
+				const changeId = task?.changeId;
+				if (!changeId || changeIds.has(changeId)) continue;
+				if (changeIds.size >= maxSessionPullRequests) {
+					truncated = true;
+					limitReached = true;
+					break;
+				}
+				changeIds.add(changeId);
+			}
+			cursor = page.nextCursor ?? void 0;
+			if (cursor && pages >= maxRelatedTaskPages) {
+				truncated = true;
+				limitReached = true;
+			}
+		} while (cursor && !limitReached);
+		const targets = (await mapConcurrent([...changeIds].slice(0, maxSessionPullRequests), async (changeId) => {
+			const change = await stores.changes.get(changeId);
+			if (!change) return null;
+			const repository = await stores.repositories.get(change.repositoryId);
+			const allowedRepositoryIds = session.external?.repositoryIds ?? (session.repositoryId ? [session.repositoryId] : []);
+			if (!repository || !allowedRepositoryIds.includes(repository.id)) return null;
 			return {
-				session,
-				task: null,
-				execution: session.execution ?? null,
-				activeAgent: session.agent,
-				source: session.external.replyTo.channel,
-				relatedTasks,
-				question,
-				canFollowUp: false,
-				...humanAttention ? { attention: humanAttention } : {}
+				change,
+				repository
 			};
+		})).filter((target) => target !== null);
+		if (!targets.length) return {
+			pullRequests: [],
+			truncated
+		};
+		const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+		let observations;
+		if (!options.pullRequestStatuses) observations = targets.map(({ change }) => ({
+			changeId: change.id,
+			state: null,
+			sync: "unavailable",
+			checkedAt,
+			syncMessage: "Live pull request status is not configured for this factory."
+		}));
+		else try {
+			observations = z.array(pullRequestStatusObservationSchema).max(maxSessionPullRequests).parse(await options.pullRequestStatuses({
+				pullRequests: targets,
+				signal
+			}));
+		} catch (error) {
+			options.reportError?.(error, {
+				method: "GET",
+				path: "session-pull-requests"
+			});
+			observations = targets.map(({ change }) => ({
+				changeId: change.id,
+				state: null,
+				sync: "unavailable",
+				checkedAt,
+				syncMessage: "Live pull request status could not be refreshed."
+			}));
 		}
-		const boundTask = !snapshot && session.taskId ? await stores.tasks.get(session.taskId) : null;
-		const addressed = (!snapshot || session.notifications.some((event) => ["question", "failed"].includes(event.outcome))) && (boundTask || session.repositoryId !== void 0) ? await stores.tasks.forReplyTo({
-			channel: "api",
-			address: session.id
-		}) : [];
-		const byId = new Map([...snapshot?.tasks ?? [], ...addressed.map((task) => [task.id, task])]);
-		if (boundTask) byId.set(boundTask.id, boundTask);
-		const { root, relatedTasks, tasks } = sessionTasks(session, byId);
-		const task = tasks.at(-1) ?? null;
-		const questionParents = [...tasks, ...workflowTasks(session, byId.values())];
-		if (!snapshot) await mapConcurrent(questionParents.filter((item) => item.state === "needs_human" && item.questionTaskId), async (item) => {
-			const question = await stores.tasks.get(item.questionTaskId);
-			if (question) byId.set(question.id, question);
-		});
-		const question = conversationQuestion(questionParents, byId);
-		const history = [];
-		const includeHistory = detail === "full" && snapshot?.receipts !== null;
-		const receipts = tasks.length && includeHistory ? snapshot?.receipts ?? await stores.receipts.list() : [];
-		for (const item of includeHistory ? tasks : []) {
-			const agent = taskAgent(session, item);
-			if (!agent) continue;
-			const message = session.continuations?.find((entry) => entry.taskId === item.id)?.message ?? (item.id === root?.id ? session.message : `${item.kind.replaceAll("_", " ")} · ${item.id}`);
-			const executions = receipts.filter((receipt) => receipt.taskId === item.id && receipt.execution !== void 0).sort((a, b) => a.attempt - b.attempt || a.recordedAt.localeCompare(b.recordedAt)).flatMap((receipt) => receipt.execution ? [receipt.execution] : []);
-			if (item.execution) executions.push(item.execution);
-			for (const execution of executions) {
-				if (history.some((entry) => entry.execution.provider === execution.provider && entry.execution.sessionId === execution.sessionId)) continue;
-				const continuation = session.continuations?.find((entry) => entry.taskId === item.id);
-				const attachments = continuation ? continuation.attachments ?? [] : item.id === root?.id ? session.attachments : void 0;
-				history.push({
-					taskId: item.id,
-					agent,
-					message,
-					execution,
-					...attachments ? { attachments } : {}
-				});
-			}
+		const byChange = /* @__PURE__ */ new Map();
+		for (const observation of observations) {
+			if (!changeIds.has(observation.changeId) || byChange.has(observation.changeId)) continue;
+			byChange.set(observation.changeId, observation);
 		}
-		const activeAgent = task ? taskAgent(session, task) : session.agent;
-		const execution = (activeAgent ? task?.execution ?? (task === null ? session.execution : void 0) : void 0) ?? null;
-		const dependencyTaskIds = (task ? await stores.graphs.get(task.rootTaskId) : null)?.nodes.find((node) => node.taskId === task?.id)?.dependencies;
-		const signal = root?.origin.signalId ? await stores.signals.get(root.origin.signalId) : null;
-		const changeId = task?.changeId ?? root?.changeId ?? session.changeId;
-		const change = changeId ? snapshot?.changes ? snapshot.changes.get(changeId) ?? null : await stores.changes.get(changeId) : null;
-		const delegated = workflowTasks(session, byId.values());
-		const hasWorkflowFailure = delegated.some((item) => item.state === "failed");
-		const canCancel = task === null || !["succeeded", "cancelled"].includes(task.state) || delegated.some((item) => ![
-			"succeeded",
-			"failed",
-			"cancelled"
-		].includes(item.state));
-		const humanAttention = question ? "question" : workflowAttention(session, byId.values()) ?? attention(task, change);
 		return {
-			session: {
-				...session,
-				continuations: session.continuations?.map(({ context: _context, ...item }) => item)
+			pullRequests: (await mapConcurrent(targets, async ({ change: observed, repository }) => {
+				const change = await stores.changes.get(observed.id) ?? observed;
+				const observation = byChange.get(change.id) ?? {
+					changeId: change.id,
+					state: null,
+					sync: "unavailable",
+					checkedAt,
+					syncMessage: "Live pull request status was not returned by the configured reader."
+				};
+				const state = (change.state === "merged" || change.state === "deployed" || change.state === "rolled_out" || change.state === "rolled_back" ? "merged" : change.state === "closed" ? "closed" : null) ?? observation.state;
+				const verification = change.state === "verifying" ? "pending" : change.state === "closed" ? "unknown" : "passed";
+				const reviewReadiness = state === "draft" ? "draft" : state === "merged" ? "complete" : state === "closed" ? "closed" : change.state === "verifying" ? "not_ready" : change.state === "ready" ? "ready" : "unknown";
+				return sessionPullRequestSchema.parse({
+					changeId: change.id,
+					repositoryId: repository.id,
+					repository: repository.slug,
+					number: change.prNumber,
+					url: change.prUrl,
+					state,
+					changeState: change.state,
+					verification,
+					reviewReadiness,
+					sync: observation.sync,
+					observedAt: observation.observedAt,
+					checkedAt: observation.checkedAt,
+					syncMessage: observation.syncMessage
+				});
+			})).sort((a, b) => a.repository.localeCompare(b.repository) || a.number - b.number),
+			truncated
+		};
+	}
+	async function historyPage(session, query) {
+		const page = await stores.conversations.history(session.id, query);
+		const items = (await mapConcurrent(page.items, async (entry) => await accessibleExecution(session, entry) ? entry : null)).filter((entry) => entry !== null);
+		return {
+			...page,
+			items
+		};
+	}
+	async function accessibleExecution(session, entry) {
+		if (!agents.some((agent) => agent.id === entry.agent)) return false;
+		if (!entry.taskId) return true;
+		if (!session.taskId) return false;
+		const task = await stores.tasks.get(entry.taskId);
+		if (!task || await taskAgent(session, task) !== entry.agent) return false;
+		if (task.repositoryIds.length !== 1 || task.repositoryIds[0] !== session.repositoryId) return false;
+		if (session.attached && !await mayAccessTask(session.owner, task)) return false;
+		return true;
+	}
+	async function view(session, _snapshot, detail = "full", includePullRequests = false, signal = new AbortController().signal) {
+		const storedSummary = await stores.conversations.get(session.id);
+		const summary = storedSummary ? await authorizedSummary(storedSummary, session.owner) : null;
+		if (!summary) throw new ApiError(503, "Conversation projection is unavailable");
+		const [task, question, notifications, history, related] = await Promise.all([
+			summary.task ? stores.tasks.get(summary.task.id) : null,
+			summary.question ? stores.tasks.get(summary.question.id) : null,
+			detail === "full" ? stores.sessions.listNotifications(session.id, { limit: 30 }) : {
+				items: [],
+				nextCursor: null
+			},
+			detail === "full" ? historyPage(session, { limit: 20 }) : {
+				items: [],
+				nextCursor: null
 			},
+			detail === "full" ? stores.tasks.list({
+				limit: 30,
+				...relatedQuery(session)
+			}) : {
+				items: [],
+				nextCursor: null
+			}
+		]);
+		const continuation = task ? await stores.sessions.getContinuation(session.id, task.id) : null;
+		const relatedTasks = (await mapConcurrent(related.items, (item) => authorizedRelatedTask(session, item))).filter((item) => item !== null);
+		const associated = includePullRequests ? await sessionPullRequests(session, task, signal) : {
+			pullRequests: [],
+			truncated: false
+		};
+		const workGroups = detail === "full" ? await sessionWorkGroups(session, task, relatedTasks, associated.pullRequests) : [];
+		return sessionViewSchema.parse({
+			...summary,
+			session,
 			task,
-			execution,
+			finding: await sessionFinding(session, task),
+			question,
+			continuation,
+			notifications: [...notifications.items].reverse(),
+			notificationsNextCursor: notifications.nextCursor,
+			history: detail === "full" && !session.external ? [...history.items].reverse().filter((item) => item.execution.sessionId !== summary.execution?.sessionId || item.execution.provider !== summary.execution?.provider) : void 0,
+			historyNextCursor: history.nextCursor,
 			relatedTasks,
-			activeAgent,
-			dependencyTaskIds,
-			source: session.attached ? signal?.source ?? "factory" : void 0,
-			prUrl: change?.prUrl,
-			...humanAttention ? { attention: humanAttention } : {},
-			hasWorkflowFailure,
-			canCancel,
-			canFollowUp: options.continuationAgent !== void 0 && root !== null,
-			history: includeHistory ? history.filter((entry) => entry.execution.sessionId !== execution?.sessionId || entry.execution.provider !== execution?.provider) : void 0,
-			question
-		};
+			relatedTasksNextCursor: related.nextCursor,
+			pullRequests: associated.pullRequests,
+			pullRequestsTruncated: associated.truncated,
+			workGroups,
+			prUrl: summary.prUrl ?? associated.pullRequests.at(-1)?.url
+		});
 	}
 	async function listSessions(url, owner, repositories) {
-		const scope = z.enum(["all", "interactive"]).parse(url.searchParams.get("scope") ?? "all");
-		const detail = z.enum(["full", "summary"]).parse(url.searchParams.get("detail") ?? "full");
-		const limit = url.searchParams.has("limit") ? z.coerce.number().int().min(1).max(100).parse(url.searchParams.get("limit")) : void 0;
 		const filters = z.object({
-			query: z.string().trim().max(200).optional().describe("Case-insensitive terms in the request, identifiers, agent, repository, or source."),
-			repository: z.string().min(1).max(200).optional().describe("Configured owner/repository slug."),
-			agent: z.string().min(1).max(31).optional().describe("Current executing agent."),
-			source: z.literal("automatic").optional().describe("Only interactions attached to automatic work."),
-			state: z.union([taskStateSchema, z.literal("conversation")]).optional().describe("Current Task state, or conversation for taskless sessions."),
-			attention: z.enum(["true", "false"]).optional().describe("Only work requiring human attention when true."),
-			topLevel: z.enum(["true", "false"]).optional().describe("Only Task entrypoints without a parent Task; excludes taskless conversations."),
-			includeTotal: z.enum(["true", "false"]).optional().describe("Include the authorized matching count before the cursor.")
+			detail: z.enum(["full", "summary"]).optional(),
+			scope: z.enum(["all", "interactive"]).default("all"),
+			limit: z.coerce.number().int().min(1).max(100).default(30),
+			cursor: z.string().max(8192).optional(),
+			query: z.string().trim().max(200).optional(),
+			repository: repositorySlugSchema.optional(),
+			agent: z.string().min(1).max(31).optional(),
+			source: z.literal("automatic").optional(),
+			state: z.union([taskStateSchema, z.literal("conversation")]).optional(),
+			attention: z.enum(["true", "false"]).optional(),
+			topLevel: z.enum(["true", "false"]).optional(),
+			includeTotal: z.enum(["true", "false"]).optional()
 		}).parse(Object.fromEntries(url.searchParams));
-		let cursor;
-		if (url.searchParams.has("cursor")) {
-			if (limit === void 0) throw new ApiError(400, "Session cursor requires a limit");
-			try {
-				cursor = z.tuple([z.iso.datetime(), z.string().min(1).max(200)]).parse(JSON.parse(Buffer.from(url.searchParams.get("cursor"), "base64url").toString()));
-			} catch {
-				throw new ApiError(400, "Invalid session cursor");
-			}
-		}
-		const enabled = (id) => {
-			const repository = repositories.get(id);
-			return repository?.enabled && options.repositories.includes(repository.slug);
-		};
+		const enabled = [...repositories.values()].filter((repo) => repo.enabled && options.repositories.includes(repo.slug));
+		const selected = filters.repository ? enabled.find((repo) => repo.slug === filters.repository) : void 0;
+		if (filters.repository && !selected) throw new ApiError(403, "Repository is not configured");
 		const requestedIds = url.searchParams.get("ids");
 		if (requestedIds !== null) {
-			if (detail !== "summary" || [...url.searchParams.keys()].some((name) => name !== "ids" && name !== "detail")) throw new ApiError(400, "Session ids require detail=summary and cannot be combined with list filters");
+			if ([...url.searchParams.keys()].some((key) => key !== "ids" && key !== "detail")) throw new ApiError(400, "Session ids cannot be combined with list filters");
 			const ids = [...new Set(requestedIds.split(",").filter(Boolean).map((id) => agentSessionIdSchema.parse(id)))];
 			if (ids.length === 0 || ids.length > 50) throw new ApiError(400, "Session ids must contain 1–50 session IDs");
 			const sessions = await mapConcurrent(ids, async (id) => {
 				try {
-					return await owned(id, owner);
+					await owned(id, owner);
+					const summary = await stores.conversations.get(id);
+					const authorized = summary ? await authorizedSummary(summary, owner) : null;
+					return authorized ? await findingSummary(authorized) : null;
 				} catch (error) {
 					if (error instanceof ApiError && error.status === 404) return null;
 					throw error;
 				}
 			});
 			return json({
-				sessions: await mapConcurrent(sessions.filter((session) => session !== null), (session) => view(session, void 0, "summary")),
+				sessions: sessions.filter((session) => session !== null),
 				nextCursor: null
 			});
 		}
-		const stored = (await stores.sessions.summaries()).filter((session) => session.owner === owner);
-		const sessions = stored.filter((session) => (scope === "all" || !session.attached && !session.external) && agents.some((agent) => agent.id === session.agent) && (session.repositoryId === void 0 || enabled(session.repositoryId)) && (session.external === void 0 || session.external.repositoryIds.every(enabled)));
-		const tasks = scope === "all" && options.canAccessTask || filters.attention === "true" || sessions.some((session) => session.taskId !== void 0) ? await stores.tasks.list() : [];
-		const byId = new Map(tasks.map((task) => [task.id, task]));
-		const candidates = (await mapConcurrent(sessions, async (session) => {
-			if (!session.attached) return session;
-			const task = session.taskId ? byId.get(session.taskId) : void 0;
-			return task && await options.canAccessTask?.({ id: owner }, task) ? session : null;
-		})).filter((session) => session !== null).map((session) => ({
-			createdAt: session.createdAt,
-			key: session.attached ? `task:${session.taskId}` : `session:${session.id}`,
-			session,
-			load: detail === "summary" ? async () => session : async () => await stores.sessions.get(session.id) ?? session
-		}));
-		if (scope === "all" && options.canAccessTask) {
-			const attached = new Set(stored.filter((session) => session.attached).map((session) => session.taskId));
-			const discovered = await mapConcurrent(tasks, async (task) => {
-				if (attached.has(task.id) || task.replyTo.channel === "api" || task.repositoryIds.length !== 1 || !enabled(task.repositoryIds[0])) return null;
-				const binding = task.work.route;
-				const route = binding ? options.routes.get(binding) : void 0;
-				if (!route || !agents.some((agent) => agent.id === route.agent) || !await options.canAccessTask?.({ id: owner }, task)) return null;
-				return {
-					createdAt: task.createdAt,
-					key: `task:${task.id}`,
-					task,
-					load: async () => {
-						const signal = task.origin.signalId ? await stores.signals.get(task.origin.signalId) : null;
-						return stores.sessions.attachTask({
-							owner,
-							taskId: task.id,
-							agent: route.agent,
-							message: `${route.id.replaceAll("-", " ")} · ${repositories.get(task.repositoryIds[0]).slug} · ${signal?.source ?? "factory"} · ${task.replyTo.address}`.slice(0, 16e3)
-						});
-					}
-				};
-			});
-			candidates.push(...discovered.filter((candidate) => candidate !== null));
-		}
-		const filtering = filters.query || filters.repository || filters.agent || filters.state || filters.source || filters.attention === "true" || filters.topLevel === "true";
-		const linkedTasks = /* @__PURE__ */ new Map();
-		if (filtering) for (const task of tasks) {
-			if (task.replyTo.channel !== "api") continue;
-			const linked = linkedTasks.get(task.replyTo.address) ?? [];
-			linked.push(task);
-			linkedTasks.set(task.replyTo.address, linked);
-		}
-		const changes = filters.attention === "true" ? new Map((await stores.changes.list()).map((change) => [change.id, change])) : void 0;
-		const matches = (filtering ? await mapConcurrent(candidates, async (candidate) => {
-			const session = candidate.session;
-			const work = session ? sessionTasks(session, byId, linkedTasks.get(session.id) ?? []) : null;
-			const task = work?.tasks.at(-1) ?? candidate.task ?? null;
-			const root = work?.root ?? candidate.task;
-			const entryTask = session?.taskId ? byId.get(session.taskId) : candidate.task;
-			if (filters.topLevel === "true" && (entryTask === void 0 || entryTask.parentTaskId !== void 0)) return null;
-			const slugs = [.../* @__PURE__ */ new Set([
-				...root?.repositoryIds ?? [],
-				...task?.repositoryIds ?? [],
-				...session?.repositoryId ? [session.repositoryId] : [],
-				...session?.external?.repositoryIds ?? []
-			])].flatMap((id) => repositories.get(id)?.slug ?? []);
-			const agent = session ? task ? taskAgent(session, task) : session.agent : task ? taskRoute(task)?.agent : void 0;
-			if (filters.repository && !slugs.some((slug) => slug === filters.repository)) return null;
-			if (filters.agent && agent !== filters.agent) return null;
-			if (filters.state && (task?.state ?? "conversation") !== filters.state) return null;
-			if (filters.source && session && !session.attached && !session.external) return null;
-			if (filters.attention === "true") {
-				const changeId = task?.changeId ?? root?.changeId ?? session?.changeId;
-				const change = changeId ? changes?.get(changeId) ?? null : null;
-				if (session?.external ? !(await view(session, void 0, "summary")).attention : !attention(task, change) && !(session && workflowAttention(session, linkedTasks.get(session.id) ?? [])) && !conversationQuestion([...work?.tasks ?? [], ...session ? workflowTasks(session, linkedTasks.get(session.id) ?? []) : []], byId)) return null;
-			}
-			if (filters.query) {
-				const signal = root?.origin.signalId ? await stores.signals.get(root.origin.signalId) : null;
-				const route = root ? taskRoute(root) : void 0;
-				const searchable = [
-					session?.id,
-					session?.message,
-					...session?.attachments?.map((item) => item.filename) ?? [],
-					task?.id,
-					agent,
-					...slugs,
-					route?.id.replaceAll("-", " "),
-					signal?.source ?? (session?.attached || candidate.task ? "factory" : ""),
-					root?.replyTo.address,
-					session?.external?.replyTo.channel,
-					session?.external?.replyTo.address
-				].join(" ").toLowerCase();
-				if (!filters.query.toLowerCase().split(/\s+/u).every((word) => searchable.includes(word))) return null;
-			}
-			return candidate;
-		}) : candidates).filter((candidate) => candidate !== null);
-		const ordered = matches.sort((a, b) => b.createdAt.localeCompare(a.createdAt) || b.key.localeCompare(a.key)).filter((candidate) => !cursor || candidate.createdAt.localeCompare(cursor[0]) < 0 || candidate.createdAt === cursor[0] && candidate.key.localeCompare(cursor[1]) < 0);
-		const page = limit === void 0 ? ordered : ordered.slice(0, limit);
-		const visible = await mapConcurrent(page, (candidate) => candidate.load());
-		const receipts = detail === "summary" ? null : visible.some((session) => session.taskId !== void 0) ? await stores.receipts.list() : [];
-		const last = page.at(-1);
+		const shared = options.sharedWorkspaceOwner === owner;
+		const page = await stores.conversations.list({
+			owner,
+			repositoryId: selected?.id,
+			attention: filters.attention === "true",
+			limit: filters.limit,
+			cursor: filters.cursor,
+			search: filters.query || void 0,
+			includeTotal: filters.includeTotal === "true" && !options.canAccessTask,
+			match: {
+				...filters.scope === "interactive" ? { interactive: true } : {},
+				...filters.source ? { automatic: true } : {},
+				...!shared && !options.canAccessTask ? { attached: false } : {},
+				...filters.agent ? { agent: filters.agent } : {},
+				...filters.state ? { state: filters.state } : {},
+				...filters.topLevel === "true" ? { topLevel: true } : {}
+			},
+			fields: [
+				{
+					path: ["repositoryIds"],
+					test: "subset",
+					value: enabled.map((repo) => repo.id)
+				},
+				{
+					path: ["sessionAgent"],
+					test: "oneOf",
+					value: agents.map((agent) => agent.id)
+				},
+				{
+					path: ["agent"],
+					test: "oneOf",
+					value: agents.map((agent) => agent.id)
+				},
+				{
+					path: ["routeAgent"],
+					test: "oneOf",
+					value: [
+						...agents.map((agent) => JSON.stringify(["", agent.id])),
+						...options.continuationAgent ? [JSON.stringify(["conversation@1", options.continuationAgent])] : [],
+						...options.routes.routes.filter((route) => agents.some((agent) => agent.id === route.agent)).map((route) => JSON.stringify([`${route.id}@${route.version}`, route.agent]))
+					]
+				}
+			]
+		});
+		const sessions = options.canAccessTask ? (await mapConcurrent(page.items, (summary) => authorizedSummary(summary, owner))).filter((summary) => summary !== null) : page.items;
 		return json({
-			sessions: await mapConcurrent(visible, (session) => view(session, {
-				tasks: byId,
-				receipts,
-				changes
-			}, detail)),
-			...filters.includeTotal === "true" ? { totalCount: matches.length } : {},
-			...limit === void 0 ? {} : { nextCursor: last && ordered.length > page.length ? Buffer.from(JSON.stringify([last.createdAt, last.key])).toString("base64url") : null }
+			sessions: await mapConcurrent(sessions, findingSummary),
+			nextCursor: page.nextCursor,
+			...page.totalCount === void 0 ? {} : { totalCount: page.totalCount }
 		});
 	}
 	async function assertRepository(id) {
@@ -438,7 +626,7 @@ function createFactoryApi(options) {
 		if (session.external) await mapConcurrent(session.external.repositoryIds, assertRepository);
 		if (session.attached) {
 			const task = session.taskId ? await stores.tasks.get(session.taskId) : null;
-			if (!task || !await options.canAccessTask?.({ id: owner }, task)) throw new ApiError(404, "Session not found");
+			if (!task || !await mayAccessTask(owner, task)) throw new ApiError(404, "Session not found");
 		}
 		return session;
 	}
@@ -451,15 +639,41 @@ function createFactoryApi(options) {
 			}
 		} else {
 			const boundTask = session.taskId === current.task.id ? current.task : session.taskId ? await stores.tasks.get(session.taskId) : null;
-			const tasks = [...boundTask ? [boundTask] : [], ...current.relatedTasks ?? []];
-			const task = recoveryTaskId ? tasks.find((item) => item.id === recoveryTaskId) : tasks.find((item) => item.state === "queued" && item.answerEventIds?.length) ?? current.task;
+			const recovery = recoveryTaskId ? await stores.tasks.get(taskIdSchema.parse(recoveryTaskId)) : null;
+			if (recoveryTaskId && (!recovery || recovery.id !== session.taskId && (recovery.replyTo.channel !== "api" || recovery.replyTo.address !== session.id || recovery.repositoryIds.length !== 1 || recovery.repositoryIds[0] !== session.repositoryId))) throw new ApiError(403, "Recovery Task does not belong to this interaction");
+			const answered = recoveryTaskId ? null : (await stores.tasks.list({
+				limit: 1,
+				match: {
+					replyTo: {
+						channel: "api",
+						address: session.id
+					},
+					state: "queued"
+				},
+				fields: [
+					{
+						path: ["repositoryIds"],
+						test: "eq",
+						value: session.repositoryId ? [session.repositoryId] : []
+					},
+					{
+						path: ["work", "route"],
+						test: "exists"
+					},
+					{
+						path: ["answerEventIds"],
+						test: "notEmpty"
+					}
+				]
+			})).items[0];
+			const task = recovery ?? (boundTask?.state === "queued" && boundTask.answerEventIds?.length ? boundTask : answered) ?? current.task;
 			if (task?.state === "queued") {
-				if (!taskAgent(session, task)) throw new ApiError(409, "Task has no configured agent route");
+				if (!await taskAgent(session, task)) throw new ApiError(409, "Task has no configured agent route");
 				const answers = await Promise.all((task.answerEventIds ?? []).map((id) => stores.answers.get(id)));
 				const message = [
 					`You are assigned Factory task ${task.id}. Read it before starting.`,
 					session.changeId === void 0 ? "" : `Existing change: ${session.changeId}.`,
-					session.continuations?.find((item) => item.taskId === task.id)?.message ?? session.message,
+					(await stores.sessions.getContinuation(session.id, task.id))?.message ?? session.message,
 					...answers.flatMap((answer) => answer === null ? [] : [`${answer.question}\nAnswer: ${answer.answer}`])
 				].filter(Boolean).join("\n\n");
 				try {
@@ -468,14 +682,14 @@ function createFactoryApi(options) {
 						route: task.work.route,
 						budget: options.budget,
 						launch: async (running) => {
-							const continuation = session.continuations?.find((item) => item.taskId === running.id);
-							if (continuation && (continuation.agent !== options.continuationAgent || taskAgent(session, running) !== continuation.agent)) throw new ApiError(409, "Conversation agent is no longer configured");
-							if (continuation) return start(executionSession(session, running), running, await continuationBrief(session, current, continuation.message, running.id), `factory-task:${running.id}:${running.attempt}`);
+							const continuation = await stores.sessions.getContinuation(session.id, running.id);
+							if (continuation && (continuation.agent !== options.continuationAgent || await taskAgent(session, running) !== continuation.agent)) throw new ApiError(409, "Conversation agent is no longer configured");
+							if (continuation) return start(await executionSession(session, running), running, await continuationBrief(session, current, continuation.message, running.id), `factory-task:${running.id}:${running.attempt}`);
 							if (session.attached || running.id !== session.taskId) {
 								if (!options.resumeTask) throw new ApiError(409, "Recovery for existing work is not configured");
 								return options.resumeTask(running);
 							}
-							return start(executionSession(session, running), running, message, `factory-task:${running.id}:${running.attempt}`);
+							return start(await executionSession(session, running), running, message, `factory-task:${running.id}:${running.attempt}`);
 						}
 					});
 				} catch (error) {
@@ -575,11 +789,20 @@ function createFactoryApi(options) {
 		const repository = await stores.repositories.get(repositoryId);
 		if (!repository) throw new ApiError(404, "Repository not found");
 		await assertRepository(repositoryId);
-		const active = (await stores.tasks.list()).find((task) => task.kind === "security_scan" && task.repositoryIds.includes(repository.id) && ![
-			"succeeded",
-			"failed",
-			"cancelled"
-		].includes(task.state));
+		const active = (await stores.tasks.list({
+			limit: 1,
+			match: [
+				"queued",
+				"running",
+				"needs_human",
+				"stalled",
+				"verifying"
+			].map((state) => ({
+				kind: "security_scan",
+				repositoryIds: [repository.id],
+				state
+			}))
+		})).items[0];
 		if (active) return json({
 			taskId: active.id,
 			reused: true
@@ -609,7 +832,7 @@ function createFactoryApi(options) {
 		}, 202);
 	}
 	async function continuationBrief(session, current, message, taskId) {
-		const continuation = session.continuations?.find((item) => item.taskId === taskId);
+		const continuation = await stores.sessions.getContinuation(session.id, taskId);
 		const saved = continuation?.context;
 		const historicalImages = [];
 		const task = await stores.tasks.get(taskId);
@@ -625,9 +848,9 @@ function createFactoryApi(options) {
 			execution: current.execution
 		});
 		const sections = await Promise.all(entries.slice(-12).map(async (entry, index) => {
-			const task = entry.taskId ? await stores.tasks.get(entry.taskId) : null;
 			try {
-				const snapshot = await materializedTranscript(session, task, entry.agent, entry.execution, AbortSignal.timeout(15e3));
+				const snapshot = (await stores.transcripts.page(entry.execution, { limit: 100 }))?.snapshot;
+				if (!snapshot || snapshot.cursor === 0) throw new ApiError(404, "Transcript has not been persisted yet");
 				const transcript = new Transcript();
 				transcript.hydrate(snapshot);
 				historicalImages[index] = transcript.blocks.flatMap((block) => block.attachments ?? []);
@@ -642,7 +865,7 @@ function createFactoryApi(options) {
 		}));
 		const candidates = [
 			...session.attachments ?? [],
-			...session.continuations?.slice(-12).flatMap((item) => item.contextAttachments ?? item.attachments ?? []) ?? [],
+			...(await stores.sessions.listContinuations(session.id, { limit: 12 })).items.flatMap((item) => item.contextAttachments ?? item.attachments ?? []),
 			...historicalImages.flat(),
 			...continuation?.attachments ?? []
 		];
@@ -688,38 +911,32 @@ function createFactoryApi(options) {
 			attachments: selected
 		}));
 	}
-	async function materializedTranscript(session, task, agent, execution, signal) {
-		const cached = await stores.transcripts.get(execution);
-		if (cached !== null && cached.state !== "running" && cached.state !== "connecting") return cached;
-		const transcript = new Transcript();
-		if (cached !== null) transcript.hydrate(cached);
-		const path = `/stream?${new URLSearchParams({
-			startIndex: String(transcript.cursor),
-			includeTailIndex: "1"
-		})}`;
-		const response = await options.forward({
-			session: executionSession(session, task, agent),
-			execution,
-			path,
-			request: new Request("http://factory/transcript", { signal: AbortSignal.any([signal, AbortSignal.timeout(15e3)]) })
-		});
-		if (!response.ok || !response.body) {
-			await response.body?.cancel();
-			throw new ApiError(response.status || 502, response.status === 404 ? "Execution transcript is unavailable on this deployment. It may belong to another deployment or have expired." : "Execution transcript is unavailable");
+	async function transcriptResponse(url, execution) {
+		const blockId = url.searchParams.get("blockId");
+		if (blockId !== null) {
+			z.string().min(1).max(1e3).parse(blockId);
+			if (url.searchParams.has("cursor") || url.searchParams.has("limit")) throw new ApiError(400, "Block reads cannot include page parameters");
+			const block = await stores.transcripts.block(execution, blockId);
+			if (!block) throw new ApiError(404, "Transcript block not found");
+			return json(block);
 		}
-		const tailValue = response.headers.get("x-eve-stream-tail-index");
-		const tail = tailValue === null ? NaN : Number(tailValue);
-		if (!Number.isSafeInteger(tail) || tail < -1) {
-			await response.body.cancel();
-			throw new Error("Execution transcript did not include a valid durable cursor");
-		}
-		if (transcript.cursor <= tail) for await (const event of readEvents(response.body)) {
-			transcript.accept(event);
-			if (transcript.cursor === tail + 1) break;
-		}
-		else await response.body.cancel();
-		if (transcript.cursor !== tail + 1) throw new Error("Execution transcript closed before its durable cursor");
-		return stores.transcripts.put(execution, transcript.snapshot());
+		const limit = z.coerce.number().int().min(1).max(100).parse(url.searchParams.get("limit") ?? 30);
+		const cursor = url.searchParams.get("cursor") ?? void 0;
+		const page = await stores.transcripts.page(execution, {
+			limit,
+			cursor
+		});
+		return page ? json(page) : json({
+			snapshot: {
+				blocks: [],
+				inputs: [],
+				cursor: 0,
+				state: "connecting",
+				tokens: 0
+			},
+			nextCursor: null,
+			totalBlocks: 0
+		}, 202);
 	}
 	async function proxy(session, request, suffix, payload) {
 		const current = await view(session, void 0, "summary");
@@ -747,7 +964,7 @@ function createFactoryApi(options) {
 			...request.method === "POST" ? { body: JSON.stringify(payload !== null && typeof payload === "object" ? Object.fromEntries(Object.entries(payload).filter(([key]) => key !== "executionId" && key !== "operationId")) : {}) } : {}
 		});
 		const result = await options.forward({
-			session: executionSession(session, current.task),
+			session: await executionSession(session, current.task),
 			execution: current.execution,
 			path: suffix,
 			request: upstream
@@ -803,36 +1020,50 @@ function createFactoryApi(options) {
 			if (path.length > 3) throw new ApiError(404, "API route not found");
 			if (resource === "intake") {
 				if (!auth.actor || !(options.operators ?? []).includes(auth.actor)) throw new ApiError(403, "Intake requires an individually authenticated configured operator");
-				const repos = (await stores.repositories.list()).filter((repo) => repo.enabled && options.repositories.includes(repo.slug));
+				const repos = (await configuredRepositories()).filter((repo) => repo.enabled && options.repositories.includes(repo.slug));
 				const repository = url.searchParams.get("repository");
 				if (repository && !options.repositories.some((slug) => slug === repository)) throw new ApiError(403, "Repository is not configured");
 				const allowed = new Map(repos.filter((repo) => !repository || repo.slug === repository).map((repo) => [repo.id, repo.slug]));
-				const tasks = await stores.tasks.list();
-				const view = (signal) => {
+				const view = async (signal) => {
+					const tasks = await stores.tasks.list({
+						limit: 30,
+						match: { origin: { signalId: signal.id } }
+					});
 					const { payload: _payload, ...record } = signal;
 					return intakeViewSchema.parse({
 						...record,
 						repository: allowed.get(signal.repositoryId),
-						taskIds: tasks.filter((task) => task.origin.signalId === signal.id).map((task) => task.id)
+						taskIds: tasks.items.map((task) => task.id),
+						tasksNextCursor: tasks.nextCursor
 					});
 				};
 				if (path.length === 1 && request.method === "GET") {
 					const limit = z.coerce.number().int().min(1).max(100).parse(url.searchParams.get("limit") ?? 100);
 					const cursor = url.searchParams.get("cursor");
-					const remaining = (await stores.signals.list()).filter((signal) => allowed.has(signal.repositoryId)).sort((a, b) => a.id.localeCompare(b.id)).filter((signal) => !cursor || signal.id > cursor);
-					const items = remaining.slice(0, limit).map(view);
+					if (allowed.size === 0) return json({
+						items: [],
+						nextCursor: null
+					});
+					const page = await stores.signals.list({
+						limit,
+						cursor: cursor ?? void 0,
+						match: [...allowed.keys()].map((repositoryId) => ({ repositoryId }))
+					});
 					return json({
-						items,
-						nextCursor: remaining.length > limit ? items.at(-1).id : null
+						items: await mapConcurrent(page.items, view),
+						nextCursor: page.nextCursor
 					});
 				}
 				if (id && path.length === 3 && action === "retry" && request.method === "POST") {
 					const signal = await stores.signals.get(signalIdSchema.parse(id));
 					if (!signal || !allowed.has(signal.repositoryId)) throw new ApiError(404, "Intake not found");
 					const input = retryIntakeSchema.parse(await body(request));
-					if (signal.outcome !== "pending" || signal.triage?.state !== "blocked" || signal.triage.attempt !== input.expectedAttempt || tasks.some((task) => task.origin.signalId === signal.id)) throw new ApiError(409, "Only the observed blocked attempt with no linked task can be retried; refresh intake");
+					if (signal.outcome !== "pending" || signal.triage?.state !== "blocked" || signal.triage.attempt !== input.expectedAttempt || (await stores.tasks.list({
+						limit: 1,
+						match: { origin: { signalId: signal.id } }
+					})).items.length > 0) throw new ApiError(409, "Only the observed blocked attempt with no linked task can be retried; refresh intake");
 					if (!options.retryIntake) throw new ApiError(409, "This factory has no retry launcher for this intake source");
-					return json(view(await options.retryIntake(signal, {
+					return json(await view(await options.retryIntake(signal, {
 						...input,
 						by: auth.actor
 					})));
@@ -885,7 +1116,7 @@ function createFactoryApi(options) {
 						reason: "External activity is not configured."
 					});
 					const allowedRepositories = async () => {
-						const disabled = new Set((await stores.repositories.list()).filter((repo) => !repo.enabled).map((repo) => repo.slug));
+						const disabled = new Set((await configuredRepositories()).filter((repo) => !repo.enabled).map((repo) => repo.slug));
 						return options.repositories.filter((slug) => !disabled.has(slug));
 					};
 					const repositories = await allowedRepositories();
@@ -908,7 +1139,7 @@ function createFactoryApi(options) {
 				if (resource === "agents") return json({ agents });
 				if (resource === "repositories") return json({
 					repositories: options.repositories,
-					details: (await stores.repositories.list()).filter((repo) => options.repositories.includes(repo.slug)).map(({ id, slug }) => ({
+					details: (await configuredRepositories()).filter((repo) => options.repositories.includes(repo.slug)).map(({ id, slug }) => ({
 						id,
 						slug
 					}))
@@ -916,14 +1147,44 @@ function createFactoryApi(options) {
 				const requestedRepositoryValue = resource === "changes" ? url.searchParams.get("repository") : null;
 				const requestedRepository = requestedRepositoryValue === null ? null : repositorySlugSchema.parse(requestedRepositoryValue);
 				if (requestedRepository !== null && !options.repositories.includes(requestedRepository)) throw new ApiError(403, "Repository is not configured");
-				const repositories = new Map((await stores.repositories.list()).map((repo) => [repo.id, repo]));
+				const repositories = new Map((await configuredRepositories()).map((repo) => [repo.id, repo]));
 				const enabledIds = new Set([...repositories.values()].filter((repo) => repo.enabled && options.repositories.includes(repo.slug) && (requestedRepository === null || repo.slug === requestedRepository)).map((repo) => repo.id));
-				if (resource === "changes") return json({ changes: (await stores.changes.list()).filter((change) => enabledIds.has(change.repositoryId) && (change.state === "verifying" || change.state === "ready")) });
+				const query = {
+					limit: z.coerce.number().int().min(1).max(100).parse(url.searchParams.get("limit") ?? 30),
+					cursor: url.searchParams.get("cursor") ?? void 0
+				};
+				if (resource === "changes") {
+					if (!enabledIds.size) return json({
+						changes: [],
+						nextCursor: null
+					});
+					const page = await stores.changes.list({
+						...query,
+						match: [...enabledIds].flatMap((repositoryId) => ["verifying", "ready"].map((state) => ({
+							repositoryId,
+							state
+						})))
+					});
+					return json({
+						changes: page.items,
+						nextCursor: page.nextCursor
+					});
+				}
 				if (resource === "sessions") return await listSessions(url, auth.id, repositories);
 				if (resource === "tasks") {
-					const tasks = [];
-					for (const task of await stores.tasks.list()) if (task.repositoryIds.every((id) => enabledIds.has(id)) && (task.origin.operator === auth.id || task.replyTo.channel !== "api" && await options.canAccessTask?.(auth, task))) tasks.push(task);
-					return json({ tasks });
+					const page = await stores.tasks.list({
+						...query,
+						fields: [{
+							path: ["repositoryIds"],
+							test: "subset",
+							value: [...enabledIds]
+						}]
+					});
+					const tasks = (await mapConcurrent(page.items, async (task) => task.origin.operator === auth.id || task.replyTo.channel !== "api" && await mayAccessTask(auth.id, task) ? task : null)).filter((task) => task !== null);
+					return json({
+						tasks,
+						nextCursor: page.nextCursor
+					});
 				}
 			}
 			if (request.method === "POST" && path.length === 1 && (resource === "signals" || resource === "sessions")) return await create(request, auth.id, resource === "sessions");
@@ -932,10 +1193,11 @@ function createFactoryApi(options) {
 			if (session.external && request.method === "POST") throw new ApiError(403, "External conversations are read-only; continue in the original channel");
 			if (request.method === "GET" && action === void 0) {
 				const detail = z.enum(["full", "summary"]).parse(url.searchParams.get("detail") ?? "full");
-				return json(await view(session, void 0, detail));
+				return json(await view(session, void 0, detail, true, request.signal));
 			}
 			if (request.method === "GET" && (action === "graph" || action === "graph-transcript" || action === "graph-stream")) {
-				const graph = await readSessionGraph(options, session);
+				const taskId = (action === "graph" ? taskIdSchema.optional() : taskIdSchema).parse(url.searchParams.get("taskId") ?? void 0);
+				const graph = await readSessionGraph(options, session, taskId);
 				if (action === "graph") {
 					const current = await view(session, void 0, "summary");
 					const currentTaskId = graph.nodes.find((node) => node.task.id === current.task?.id)?.task.id ?? null;
@@ -945,7 +1207,6 @@ function createFactoryApi(options) {
 						nodes: graph.nodes.map(({ session: _session, ...node }) => node)
 					}));
 				}
-				const taskId = taskIdSchema.parse(url.searchParams.get("taskId"));
 				const node = graph.nodes.find((item) => item.task.id === taskId);
 				if (!node) throw new ApiError(404, "Task is not part of this graph");
 				const execution = node.task.execution;
@@ -958,7 +1219,7 @@ function createFactoryApi(options) {
 						if (value !== null) query.set(name, value);
 					}
 					const response = await options.forward({
-						session: executionSession(node.session, node.task, node.agent),
+						session: await executionSession(node.session, node.task, node.agent),
 						execution,
 						path: `/stream?${query}`,
 						request
@@ -978,10 +1239,10 @@ function createFactoryApi(options) {
 						}
 					});
 				}
-				const snapshot = await materializedTranscript(node.session, node.task, node.agent, execution, request.signal);
+				const response = await transcriptResponse(url, execution);
 				const latest = await stores.tasks.get(node.task.id);
 				if (latest?.execution?.sessionId !== execution.sessionId || latest.execution.provider !== execution.provider) throw new ApiError(409, "Execution changed; refresh the graph.");
-				return json(snapshot);
+				return response;
 			}
 			if (request.method === "GET" && (action === "review" || action === "previews")) {
 				const current = await view(session, void 0, "summary");
@@ -995,17 +1256,31 @@ function createFactoryApi(options) {
 					reason: action === "review" ? "Review evidence is not configured for this factory." : "Live previews are not configured for this factory."
 				});
 				const reviewTasks = async (value) => {
-					const delegated = value.session.external ? [] : workflowTasks(value.session, await stores.tasks.forReplyTo({
-						channel: "api",
-						address: value.session.id
-					}));
-					return [...new Map([
-						...value.task ? [value.task] : [],
-						...value.relatedTasks ?? [],
-						...delegated
-					].map((task) => [task.id, task])).values()].sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
+					const page = value.session.external ? {
+						items: [],
+						nextCursor: null
+					} : await stores.tasks.list({
+						limit: 100,
+						match: { replyTo: {
+							channel: "api",
+							address: value.session.id
+						} },
+						fields: [{
+							path: ["repositoryIds"],
+							test: "eq",
+							value: value.session.repositoryId ? [value.session.repositoryId] : []
+						}, {
+							path: ["question"],
+							test: "missing"
+						}]
+					});
+					return {
+						tasks: [...new Map([...value.task ? [value.task] : [], ...page.items].map((task) => [task.id, task])).values()].sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id)),
+						truncated: page.nextCursor !== null
+					};
 				};
-				const tasks = await reviewTasks(current);
+				const selected = await reviewTasks(current);
+				const tasks = selected.tasks;
 				const identity = (value, work) => JSON.stringify([
 					value.execution,
 					value.task?.id,
@@ -1023,9 +1298,13 @@ function createFactoryApi(options) {
 					signal: request.signal
 				}));
 				const latest = await view(await owned(id, auth.id), void 0, "summary");
-				if (identity(current, tasks) !== identity(latest, await reviewTasks(latest))) throw new ApiError(409, "Execution changed; refresh the session before reviewing work");
+				if (identity(current, tasks) !== identity(latest, (await reviewTasks(latest)).tasks)) throw new ApiError(409, "Execution changed; refresh the session before reviewing work");
 				if (result.executionId !== executionId) throw new Error("Review reader returned a different execution");
-				return json(result);
+				return json(result.state === "ready" && selected.truncated ? {
+					...result,
+					truncated: true,
+					limitations: [...result.limitations, "Evidence covers the 100 most recent related Tasks and the current Task."]
+				} : result);
 			}
 			if (request.method === "GET" && action === "files") {
 				const query = workspaceFilesRequestSchema.parse({
@@ -1042,7 +1321,7 @@ function createFactoryApi(options) {
 					reason: execution ? "File browsing is not configured for this factory." : "The workspace is not available yet."
 				});
 				const result = workspaceFilesSchema.parse(await options.workspaceFiles({
-					session: executionSession(session, current.task),
+					session: await executionSession(session, current.task),
 					execution,
 					query,
 					signal: request.signal
@@ -1061,7 +1340,7 @@ function createFactoryApi(options) {
 					reason: execution ? "Workspace inspection is not configured for this factory." : "The workspace is not available yet."
 				}));
 				const result = workspaceDiffSchema.parse(await options.workspaceDiff({
-					session: executionSession(session, current.task),
+					session: await executionSession(session, current.task),
 					execution,
 					signal: request.signal
 				}));
@@ -1070,17 +1349,37 @@ function createFactoryApi(options) {
 				if (result.executionId !== execution.sessionId) throw new Error("Workspace inspection returned a different execution");
 				return json(result);
 			}
+			if (request.method === "GET" && [
+				"history",
+				"notifications",
+				"related-tasks"
+			].includes(action ?? "")) {
+				const query = {
+					limit: z.coerce.number().int().min(1).max(100).parse(url.searchParams.get("limit") ?? 30),
+					cursor: url.searchParams.get("cursor") ?? void 0
+				};
+				if (action === "history") return json(await historyPage(session, query));
+				if (action === "notifications") return json(await stores.sessions.listNotifications(session.id, query));
+				const page = await stores.tasks.list({
+					...query,
+					...relatedQuery(session)
+				});
+				const items = (await mapConcurrent(page.items, async (task) => session.external ? task.repositoryIds.every((id) => session.external.repositoryIds.includes(id)) && await mayAccessTask(session.owner, task) ? task : null : task.repositoryIds.length === 1 && task.repositoryIds[0] === session.repositoryId ? task : null)).filter((task) => task !== null);
+				return json({
+					items,
+					nextCursor: page.nextCursor
+				});
+			}
 			if (request.method === "GET" && action === "transcript") {
 				const executionId = z.string().min(1).parse(url.searchParams.get("executionId"));
 				if (url.searchParams.get("history") === "1") {
-					const entry = (await view(session)).history?.find((item) => item.execution.sessionId === executionId);
-					if (!entry) throw new ApiError(404, "Execution is not part of this conversation history");
-					const task = entry.taskId ? await stores.tasks.get(entry.taskId) : null;
-					return json(await materializedTranscript(session, task, entry.agent, entry.execution, request.signal));
+					const entry = await stores.conversations.execution(session.id, executionId);
+					if (!entry || !await accessibleExecution(session, entry)) throw new ApiError(404, "Execution is not part of this conversation history");
+					return await transcriptResponse(url, entry.execution);
 				}
 				const current = await view(session, void 0, "summary");
 				if (current.execution?.sessionId !== executionId) throw new ApiError(409, "Execution changed; refresh the session before loading its transcript");
-				return json(await materializedTranscript(session, current.task, current.activeAgent ?? session.agent, current.execution, request.signal));
+				return await transcriptResponse(url, current.execution);
 			}
 			if (request.method === "GET" && action === "stream") {
 				const query = new URLSearchParams();
@@ -1089,12 +1388,12 @@ function createFactoryApi(options) {
 					if (value !== null) query.set(name, value);
 				}
 				if (url.searchParams.get("history") === "1") {
-					const entry = (await view(session)).history?.find((item) => item.execution.sessionId === url.searchParams.get("executionId"));
-					if (!entry) throw new ApiError(404, "Execution is not part of this conversation history");
+					const entry = await stores.conversations.execution(session.id, z.string().min(1).parse(url.searchParams.get("executionId")));
+					if (!entry || !await accessibleExecution(session, entry)) throw new ApiError(404, "Execution is not part of this conversation history");
 					query.set("includeTailIndex", "1");
 					const task = entry.taskId ? await stores.tasks.get(entry.taskId) : null;
 					const response = await options.forward({
-						session: executionSession(session, task, entry.agent),
+						session: await executionSession(session, task, entry.agent),
 						execution: entry.execution,
 						path: `/stream?${query}`,
 						request
@@ -1114,7 +1413,7 @@ function createFactoryApi(options) {
 			if (request.method !== "POST") throw new ApiError(405, "Use GET or POST for this route");
 			if (action === "messages") {
 				const input = sendSessionMessageRequestSchema.parse(await body(request));
-				const previous = input.operationId ? session.continuations?.find((item) => item.operationId === input.operationId) : void 0;
+				const previous = input.operationId ? await stores.sessions.getContinuationByOperation(session.id, input.operationId) : void 0;
 				if (previous) {
 					if (previous.message !== input.message || JSON.stringify(previous.attachments ?? []) !== JSON.stringify(input.attachments ?? [])) throw new ApiError(409, "Follow-up operationId was reused with different input");
 					const recovered = await stores.sessions.continue(session.id, previous);
@@ -1122,7 +1421,7 @@ function createFactoryApi(options) {
 					return json(current.task?.id === previous.taskId ? await launch(recovered) : current, 202);
 				}
 				const current = await view(session);
-				if (current.task?.state === "running" && session.continuations?.some((item) => item.taskId === current.task?.id)) throw new ApiError(409, "Wait for this discussion turn to finish before sending another follow-up");
+				if (current.task?.state === "running" && await stores.sessions.getContinuation(session.id, current.task.id)) throw new ApiError(409, "Wait for this discussion turn to finish before sending another follow-up");
 				if ((current.execution?.sessionId ?? null) !== input.executionId) throw new ApiError(409, "Execution changed; refresh the session before continuing");
 				if (current.task && [
 					"succeeded",
@@ -1148,11 +1447,8 @@ function createFactoryApi(options) {
 				const input = answerSessionQuestionRequestSchema.parse(await body(request));
 				const current = await view(session);
 				const question = await stores.tasks.get(input.questionId);
-				const parent = session.taskId && question?.parentTaskId === session.taskId ? await stores.tasks.get(session.taskId) : current.relatedTasks?.find((task) => task.id === question?.parentTaskId) ?? workflowTasks(session, await stores.tasks.forReplyTo({
-					channel: "api",
-					address: session.id
-				})).find((task) => task.id === question?.parentTaskId);
-				if (!question?.question || !parent || question.replyTo.channel !== parent.replyTo.channel || question.replyTo.address !== parent.replyTo.address) throw new ApiError(403, "Question does not belong to this interaction");
+				const parent = session.taskId && question?.parentTaskId === session.taskId ? await stores.tasks.get(session.taskId) : current.relatedTasks?.find((task) => task.id === question?.parentTaskId) ?? (question?.parentTaskId ? await stores.tasks.get(question.parentTaskId) : null);
+				if (!question?.question || !parent || parent.id !== session.taskId && (parent.replyTo.channel !== "api" || parent.replyTo.address !== session.id || parent.repositoryIds.length !== 1 || parent.repositoryIds[0] !== session.repositoryId) || question.replyTo.channel !== parent.replyTo.channel || question.replyTo.address !== parent.replyTo.address) throw new ApiError(403, "Question does not belong to this interaction");
 				await stores.tasks.answerQuestion({
 					questionTaskId: question.id,
 					answer: input.answer,
@@ -1171,9 +1467,28 @@ function createFactoryApi(options) {
 				const current = await view(session);
 				if (input.executionId !== void 0 && input.executionId !== current.execution?.sessionId) throw new ApiError(409, "Execution changed; refresh the session");
 				if (action === "cancel" || action === "reset") {
-					const delegated = workflowTasks(session, await stores.tasks.forReplyTo({
-						channel: "api",
-						address: session.id
+					const delegated = workflowTasks(session, await collectFactoryRecords(stores.tasks.list, {
+						limit: 100,
+						match: [
+							"queued",
+							"running",
+							"verifying",
+							"needs_human",
+							"stalled"
+						].map((state) => ({
+							replyTo: {
+								channel: "api",
+								address: session.id
+							},
+							state
+						})),
+						fields: [{
+							path: ["work", "route"],
+							test: "missing"
+						}, {
+							path: ["question"],
+							test: "missing"
+						}]
 					}));
 					for (const task of delegated) if (![
 						"succeeded",
@@ -1210,6 +1525,7 @@ function createFactoryApi(options) {
 				error: error.message,
 				...error instanceof ApprovalAccessError && error.actor ? { actor: error.actor } : {}
 			}, error.status);
+			if (error instanceof InvalidStoreQueryError) return json({ error: error.message }, 400);
 			if (error instanceof z.ZodError) return json({
 				error: "Invalid request",
 				issues: error.issues
@@ -1225,9 +1541,9 @@ function createFactoryApi(options) {
 	}
 	async function startContinuation(task) {
 		const session = task.replyTo.channel === "api" ? await stores.sessions.get(agentSessionIdSchema.parse(task.replyTo.address)) : null;
-		const continuation = session?.continuations?.find((item) => item.taskId === task.id);
-		if (!session || !continuation || continuation.agent !== options.continuationAgent || taskAgent(session, task) !== continuation.agent) throw new ApiError(409, "Conversation continuation is no longer configured");
-		return start(executionSession(session, task), task, await continuationBrief(session, await view(session), continuation.message, task.id), `factory-task:${task.id}:${task.attempt}`);
+		const continuation = session ? await stores.sessions.getContinuation(session.id, task.id) : null;
+		if (!session || !continuation || continuation.agent !== options.continuationAgent || await taskAgent(session, task) !== continuation.agent) throw new ApiError(409, "Conversation continuation is no longer configured");
+		return start(await executionSession(session, task), task, await continuationBrief(session, await view(session), continuation.message, task.id), `factory-task:${task.id}:${task.attempt}`);
 	}
 	return {
 		handle,
@@ -1271,6 +1587,6 @@ async function body(request, limit = 64e3) {
 	}
 }
 //#endregion
-export { ImageInputError, SessionConflictError, agentModelConfigSchema, agentSessionIdSchema, agentSessionSchema, answerSessionQuestionRequestSchema, apiAgentSchema, assembleWorkspaceDiff, controlSessionRequestSchema, createFactoryApi, createSessionRequestSchema, imagePartFilename, inboxActivityItemSchema, inboxActivitySchema, modelSettingsSchema, repositoryDetailsSchema, repositorySummarySchema, resolveImageMessage, sendSessionMessageRequestSchema, sessionInputResponseSchema, sessionPageSchema, sessionPreviewSchema, sessionPreviewsSchema, sessionReviewCheckSchema, sessionReviewIssueSchema, sessionReviewSchema, sessionReviewScreenshotSchema, sessionViewSchema, submitSessionInputRequestSchema, unavailableWorkspaceDiff, updateModelDefaultsSchema, workspaceDiffFileSchema, workspaceDiffSchema, workspaceFileContentSchema, workspaceFileEntrySchema, workspaceFilesRequestSchema, workspaceFilesSchema, workspaceGitFilesScript, workspacePathSchema, workspaceSnapshotSchema, workspaceSnapshotScript };
+export { ImageInputError, SessionConflictError, agentModelConfigSchema, agentSessionIdSchema, agentSessionSchema, answerSessionQuestionRequestSchema, apiAgentSchema, assembleWorkspaceDiff, controlSessionRequestSchema, createFactoryApi, createSessionRequestSchema, imagePartFilename, inboxActivityItemSchema, inboxActivitySchema, modelSettingsSchema, repositoryDetailsSchema, repositorySummarySchema, resolveImageMessage, sendSessionMessageRequestSchema, sessionInputResponseSchema, sessionPageSchema, sessionPreviewSchema, sessionPreviewsSchema, sessionPullRequestSchema, sessionPullRequestStateSchema, sessionReviewCheckSchema, sessionReviewIssueSchema, sessionReviewSchema, sessionReviewScreenshotSchema, sessionViewSchema, sessionWorkGroupSchema, sessionWorkResultSchema, sessionWorkTaskSchema, submitSessionInputRequestSchema, unavailableWorkspaceDiff, updateModelDefaultsSchema, workspaceDiffFileSchema, workspaceDiffSchema, workspaceFileContentSchema, workspaceFileEntrySchema, workspaceFilesRequestSchema, workspaceFilesSchema, workspaceGitFilesScript, workspacePathSchema, workspaceSnapshotSchema, workspaceSnapshotScript };
 
 //# sourceMappingURL=api.mjs.map