feat: wire all remaining API endpoints

- src/api/keys.ts: QK singleton for all 20+ query key patterns
- src/api/queries.ts: rewritten with QK + full mutation coverage:
  deleteWorkspace, updateWorkspace, scheduleDream,
  updatePeer, setPeerCard, searchPeer,
  deleteSession, updateSession, cloneSession, searchSession,
  createMessages, updateMessage,
  useSessionPeers, addPeersToSession, setSessionPeers,
  removePeersFromSession, setPeerConfig,
  createConclusion, deleteConclusion,
  useWebhooks, createWebhook, deleteWebhook, testWebhook,
  createKey

Shared primitives (just-in-time):
- ConfirmDialog: animated modal with keyboard/click-out dismiss
- FormModal: reusable modal shell
- InlineEditor: click-to-edit with commit/cancel

New surfaces:
- WorkspaceDetail: delete + schedule dream buttons
- ScheduleDreamModal: Zod-validated observer/session form
- WebhookManager: full CRUD + test emit (new /webhooks route)
- SessionDetail: delete, clone, session search, peer membership tab
- PeerDetail: editable peer card, semantic search tab
- ConclusionBrowser: create conclusion modal (Zod), per-row delete

src/api/queries.ts

@@ -1,46 +1,103 @@
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
 import { client } from "./client";
+import { QK } from "./keys";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function err(e: unknown): never {
+	throw new Error(typeof e === "object" ? JSON.stringify(e) : String(e));
+}
 
 // ─── Workspaces ──────────────────────────────────────────────────────────────
 
 export function useWorkspaces(page = 1, pageSize = 20) {
 	return useQuery({
-		queryKey: ["workspaces", page, pageSize],
+		queryKey: QK.workspaces(page, pageSize),
 		queryFn: async () => {
 			const { data, error } = await client.current.POST("/v3/workspaces/list", {
 				params: { query: { page, page_size: pageSize } },
 				body: {},
 			});
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 	});
 }
 
 export function useWorkspace(workspaceId: string) {
 	return useQuery({
-		queryKey: ["workspace", workspaceId],
+		queryKey: QK.workspace(workspaceId),
 		queryFn: async () => {
 			const { data, error } = await client.current.POST("/v3/workspaces", {
 				body: { id: workspaceId, metadata: {} },
 			});
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 		enabled: Boolean(workspaceId),
 	});
 }
 
+export function useUpdateWorkspace(workspaceId: string) {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async (body: { metadata?: Record<string, unknown> }) => {
+			const { data, error } = await client.current.PUT(
+				"/v3/workspaces/{workspace_id}",
+				{ params: { path: { workspace_id: workspaceId } }, body },
+			);
+			if (error) err(error);
+			return data!;
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: ["workspace", workspaceId] });
+			qc.invalidateQueries({ queryKey: ["workspaces"] });
+		},
+	});
+}
+
+export function useDeleteWorkspace() {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async (workspaceId: string) => {
+			const { error } = await client.current.DELETE("/v3/workspaces/{workspace_id}", {
+				params: { path: { workspace_id: workspaceId } },
+			});
+			if (error) err(error);
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: ["workspaces"] });
+		},
+	});
+}
+
+export function useScheduleDream(workspaceId: string) {
+	return useMutation({
+		mutationFn: async (body: {
+			observer: string;
+			observed?: string | null;
+			dream_type: "omni";
+			session_id?: string | null;
+		}) => {
+			const { error } = await client.current.POST(
+				"/v3/workspaces/{workspace_id}/schedule_dream",
+				{ params: { path: { workspace_id: workspaceId } }, body },
+			);
+			if (error) err(error);
+		},
+	});
+}
+
 export function useQueueStatus(workspaceId: string) {
 	return useQuery({
-		queryKey: ["queue-status", workspaceId],
+		queryKey: QK.queueStatus(workspaceId),
 		queryFn: async () => {
 			const { data, error } = await client.current.GET(
 				"/v3/workspaces/{workspace_id}/queue/status",
 				{ params: { path: { workspace_id: workspaceId } } },
 			);
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 		enabled: Boolean(workspaceId),
 		refetchInterval: 10_000,
@@ -49,7 +106,7 @@ export function useQueueStatus(workspaceId: string) {
 
 export function useSearchWorkspace(workspaceId: string, query: string, enabled = false) {
 	return useQuery({
-		queryKey: ["workspace-search", workspaceId, query],
+		queryKey: QK.workspaceSearch(workspaceId, query),
 		queryFn: async () => {
 			const { data, error } = await client.current.POST(
 				"/v3/workspaces/{workspace_id}/search",
@@ -58,8 +115,8 @@ export function useSearchWorkspace(workspaceId: string, query: string, enabled =
 					body: { query, limit: 20 },
 				},
 			);
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 		enabled: enabled && Boolean(workspaceId) && Boolean(query),
 	});
@@ -69,7 +126,7 @@ export function useSearchWorkspace(workspaceId: string, query: string, enabled =
 
 export function usePeers(workspaceId: string, page = 1, pageSize = 20) {
 	return useQuery({
-		queryKey: ["peers", workspaceId, page, pageSize],
+		queryKey: QK.peers(workspaceId, page, pageSize),
 		queryFn: async () => {
 			const { data, error } = await client.current.POST(
 				"/v3/workspaces/{workspace_id}/peers/list",
@@ -78,8 +135,8 @@ export function usePeers(workspaceId: string, page = 1, pageSize = 20) {
 					body: {},
 				},
 			);
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 		enabled: Boolean(workspaceId),
 	});
@@ -87,7 +144,7 @@ export function usePeers(workspaceId: string, page = 1, pageSize = 20) {
 
 export function usePeer(workspaceId: string, peerId: string) {
 	return useQuery({
-		queryKey: ["peer", workspaceId, peerId],
+		queryKey: QK.peer(workspaceId, peerId),
 		queryFn: async () => {
 			const { data, error } = await client.current.POST(
 				"/v3/workspaces/{workspace_id}/peers",
@@ -96,16 +153,34 @@ export function usePeer(workspaceId: string, peerId: string) {
 					body: { id: peerId, metadata: {} },
 				},
 			);
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 		enabled: Boolean(workspaceId) && Boolean(peerId),
 	});
 }
 
+export function useUpdatePeer(workspaceId: string, peerId: string) {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async (body: { metadata?: Record<string, unknown> }) => {
+			const { data, error } = await client.current.PUT(
+				"/v3/workspaces/{workspace_id}/peers/{peer_id}",
+				{ params: { path: { workspace_id: workspaceId, peer_id: peerId } }, body },
+			);
+			if (error) err(error);
+			return data!;
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: ["peer", workspaceId, peerId] });
+			qc.invalidateQueries({ queryKey: ["peers", workspaceId] });
+		},
+	});
+}
+
 export function usePeerRepresentation(workspaceId: string, peerId: string) {
 	return useQuery({
-		queryKey: ["peer-representation", workspaceId, peerId],
+		queryKey: QK.peerRepresentation(workspaceId, peerId),
 		queryFn: async () => {
 			const { data, error } = await client.current.POST(
 				"/v3/workspaces/{workspace_id}/peers/{peer_id}/representation",
@@ -114,8 +189,8 @@ export function usePeerRepresentation(workspaceId: string, peerId: string) {
 					body: { max_conclusions: 20 },
 				},
 			);
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 		enabled: Boolean(workspaceId) && Boolean(peerId),
 	});
@@ -123,33 +198,49 @@ export function usePeerRepresentation(workspaceId: string, peerId: string) {
 
 export function usePeerCard(workspaceId: string, peerId: string) {
 	return useQuery({
-		queryKey: ["peer-card", workspaceId, peerId],
+		queryKey: QK.peerCard(workspaceId, peerId),
 		queryFn: async () => {
 			const { data, error } = await client.current.GET(
 				"/v3/workspaces/{workspace_id}/peers/{peer_id}/card",
-				{
-					params: { path: { workspace_id: workspaceId, peer_id: peerId } },
-				},
+				{ params: { path: { workspace_id: workspaceId, peer_id: peerId } } },
 			);
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 		enabled: Boolean(workspaceId) && Boolean(peerId),
 	});
 }
 
+export function useSetPeerCard(workspaceId: string, peerId: string) {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async (peerCard: string[]) => {
+			const { data, error } = await client.current.PUT(
+				"/v3/workspaces/{workspace_id}/peers/{peer_id}/card",
+				{
+					params: { path: { workspace_id: workspaceId, peer_id: peerId } },
+					body: { peer_card: peerCard },
+				},
+			);
+			if (error) err(error);
+			return data!;
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: QK.peerCard(workspaceId, peerId) });
+		},
+	});
+}
+
 export function usePeerContext(workspaceId: string, peerId: string) {
 	return useQuery({
-		queryKey: ["peer-context", workspaceId, peerId],
+		queryKey: QK.peerContext(workspaceId, peerId),
 		queryFn: async () => {
 			const { data, error } = await client.current.GET(
 				"/v3/workspaces/{workspace_id}/peers/{peer_id}/context",
-				{
-					params: { path: { workspace_id: workspaceId, peer_id: peerId } },
-				},
+				{ params: { path: { workspace_id: workspaceId, peer_id: peerId } } },
 			);
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 		enabled: Boolean(workspaceId) && Boolean(peerId),
 	});
@@ -157,7 +248,7 @@ export function usePeerContext(workspaceId: string, peerId: string) {
 
 export function usePeerSessions(workspaceId: string, peerId: string, page = 1, pageSize = 20) {
 	return useQuery({
-		queryKey: ["peer-sessions", workspaceId, peerId, page, pageSize],
+		queryKey: QK.peerSessions(workspaceId, peerId, page, pageSize),
 		queryFn: async () => {
 			const { data, error } = await client.current.POST(
 				"/v3/workspaces/{workspace_id}/peers/{peer_id}/sessions",
@@ -169,15 +260,31 @@ export function usePeerSessions(workspaceId: string, peerId: string, page = 1, p
 					body: {},
 				},
 			);
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 		enabled: Boolean(workspaceId) && Boolean(peerId),
 	});
 }
 
+export function useSearchPeer(workspaceId: string, peerId: string) {
+	return useMutation({
+		mutationFn: async (query: string) => {
+			const { data, error } = await client.current.POST(
+				"/v3/workspaces/{workspace_id}/peers/{peer_id}/search",
+				{
+					params: { path: { workspace_id: workspaceId, peer_id: peerId } },
+					body: { query, limit: 20 },
+				},
+			);
+			if (error) err(error);
+			return data!;
+		},
+	});
+}
+
 export function useChat(workspaceId: string, peerId: string) {
-	const queryClient = useQueryClient();
+	const qc = useQueryClient();
 	return useMutation({
 		mutationFn: async (message: string) => {
 			const { data, error } = await client.current.POST(
@@ -187,11 +294,11 @@ export function useChat(workspaceId: string, peerId: string) {
 					body: { query: message, stream: false, reasoning_level: "low" },
 				},
 			);
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 		onSuccess: () => {
-			queryClient.invalidateQueries({ queryKey: ["peer-context", workspaceId, peerId] });
+			qc.invalidateQueries({ queryKey: ["peer-context", workspaceId, peerId] });
 		},
 	});
 }
@@ -200,7 +307,7 @@ export function useChat(workspaceId: string, peerId: string) {
 
 export function useSessions(workspaceId: string, page = 1, pageSize = 20) {
 	return useQuery({
-		queryKey: ["sessions", workspaceId, page, pageSize],
+		queryKey: QK.sessions(workspaceId, page, pageSize),
 		queryFn: async () => {
 			const { data, error } = await client.current.POST(
 				"/v3/workspaces/{workspace_id}/sessions/list",
@@ -212,13 +319,80 @@ export function useSessions(workspaceId: string, page = 1, pageSize = 20) {
 					body: {},
 				},
 			);
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 		enabled: Boolean(workspaceId),
 	});
 }
 
+export function useUpdateSession(workspaceId: string, sessionId: string) {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async (body: { metadata?: Record<string, unknown> }) => {
+			const { data, error } = await client.current.PUT(
+				"/v3/workspaces/{workspace_id}/sessions/{session_id}",
+				{ params: { path: { workspace_id: workspaceId, session_id: sessionId } }, body },
+			);
+			if (error) err(error);
+			return data!;
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: ["sessions", workspaceId] });
+		},
+	});
+}
+
+export function useDeleteSession(workspaceId: string) {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async (sessionId: string) => {
+			const { error } = await client.current.DELETE(
+				"/v3/workspaces/{workspace_id}/sessions/{session_id}",
+				{ params: { path: { workspace_id: workspaceId, session_id: sessionId } } },
+			);
+			if (error) err(error);
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: ["sessions", workspaceId] });
+			qc.invalidateQueries({ queryKey: ["peer-sessions", workspaceId] });
+		},
+	});
+}
+
+export function useCloneSession(workspaceId: string) {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async (sessionId: string) => {
+			const { data, error } = await client.current.POST(
+				"/v3/workspaces/{workspace_id}/sessions/{session_id}/clone",
+				{ params: { path: { workspace_id: workspaceId, session_id: sessionId } } },
+			);
+			if (error) err(error);
+			return data!;
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: ["sessions", workspaceId] });
+		},
+	});
+}
+
+export function useSearchSession(workspaceId: string, sessionId: string) {
+	return useMutation({
+		mutationFn: async (query: string) => {
+			const { data, error } = await client.current.POST(
+				"/v3/workspaces/{workspace_id}/sessions/{session_id}/search",
+				{
+					params: { path: { workspace_id: workspaceId, session_id: sessionId } },
+					body: { query, limit: 20 },
+				},
+			);
+			if (error) err(error);
+			return data!;
+		},
+	});
+}
+
 export function useSessionMessages(
 	workspaceId: string,
 	sessionId: string,
@@ -226,7 +400,7 @@ export function useSessionMessages(
 	pageSize = 50,
 ) {
 	return useQuery({
-		queryKey: ["session-messages", workspaceId, sessionId, page, pageSize],
+		queryKey: QK.sessionMessages(workspaceId, sessionId, page, pageSize),
 		queryFn: async () => {
 			const { data, error } = await client.current.POST(
 				"/v3/workspaces/{workspace_id}/sessions/{session_id}/messages/list",
@@ -238,25 +412,204 @@ export function useSessionMessages(
 					body: {},
 				},
 			);
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 		enabled: Boolean(workspaceId) && Boolean(sessionId),
 	});
 }
 
+export function useCreateMessages(workspaceId: string, sessionId: string) {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async (
+			messages: Array<{ content: string; peer_id: string; metadata?: Record<string, unknown> }>,
+		) => {
+			const { data, error } = await client.current.POST(
+				"/v3/workspaces/{workspace_id}/sessions/{session_id}/messages",
+				{
+					params: { path: { workspace_id: workspaceId, session_id: sessionId } },
+					body: { messages },
+				},
+			);
+			if (error) err(error);
+			return data!;
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: ["session-messages", workspaceId, sessionId] });
+		},
+	});
+}
+
+export function useUpdateMessage(workspaceId: string, sessionId: string) {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async ({
+			messageId,
+			body,
+		}: {
+			messageId: string;
+			body: { metadata?: Record<string, unknown> };
+		}) => {
+			const { data, error } = await client.current.PUT(
+				"/v3/workspaces/{workspace_id}/sessions/{session_id}/messages/{message_id}",
+				{
+					params: {
+						path: {
+							workspace_id: workspaceId,
+							session_id: sessionId,
+							message_id: messageId,
+						},
+					},
+					body,
+				},
+			);
+			if (error) err(error);
+			return data!;
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: ["session-messages", workspaceId, sessionId] });
+		},
+	});
+}
+
+// ─── Session ↔ Peer membership ────────────────────────────────────────────────
+
+export function useSessionPeers(workspaceId: string, sessionId: string) {
+	return useQuery({
+		queryKey: QK.sessionPeers(workspaceId, sessionId),
+		queryFn: async () => {
+			const { data, error } = await client.current.GET(
+				"/v3/workspaces/{workspace_id}/sessions/{session_id}/peers",
+				{ params: { path: { workspace_id: workspaceId, session_id: sessionId } } },
+			);
+			if (error) err(error);
+			return data!;
+		},
+		enabled: Boolean(workspaceId) && Boolean(sessionId),
+	});
+}
+
+type SessionPeerConfigMap = Record<
+	string,
+	{ observe_me?: boolean | null; observe_others?: boolean | null }
+>;
+
+export function useAddPeersToSession(workspaceId: string, sessionId: string) {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async (peers: SessionPeerConfigMap) => {
+			const { data, error } = await client.current.POST(
+				"/v3/workspaces/{workspace_id}/sessions/{session_id}/peers",
+				{
+					params: { path: { workspace_id: workspaceId, session_id: sessionId } },
+					body: peers,
+				},
+			);
+			if (error) err(error);
+			return data!;
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: ["session-peers", workspaceId, sessionId] });
+			qc.invalidateQueries({ queryKey: ["peer-sessions", workspaceId] });
+		},
+	});
+}
+
+export function useSetSessionPeers(workspaceId: string, sessionId: string) {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async (peers: SessionPeerConfigMap) => {
+			const { data, error } = await client.current.PUT(
+				"/v3/workspaces/{workspace_id}/sessions/{session_id}/peers",
+				{
+					params: { path: { workspace_id: workspaceId, session_id: sessionId } },
+					body: peers,
+				},
+			);
+			if (error) err(error);
+			return data!;
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: ["session-peers", workspaceId, sessionId] });
+			qc.invalidateQueries({ queryKey: ["peer-sessions", workspaceId] });
+		},
+	});
+}
+
+export function useRemovePeersFromSession(workspaceId: string, sessionId: string) {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async (peerIds: string[]) => {
+			const { error } = await client.current.DELETE(
+				"/v3/workspaces/{workspace_id}/sessions/{session_id}/peers",
+				{
+					params: { path: { workspace_id: workspaceId, session_id: sessionId } },
+					body: peerIds,
+				},
+			);
+			if (error) err(error);
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: ["session-peers", workspaceId, sessionId] });
+			qc.invalidateQueries({ queryKey: ["peer-sessions", workspaceId] });
+		},
+	});
+}
+
+export function usePeerConfig(workspaceId: string, sessionId: string, peerId: string) {
+	return useQuery({
+		queryKey: QK.peerConfig(workspaceId, sessionId, peerId),
+		queryFn: async () => {
+			const { data, error } = await client.current.GET(
+				"/v3/workspaces/{workspace_id}/sessions/{session_id}/peers/{peer_id}/config",
+				{
+					params: {
+						path: { workspace_id: workspaceId, session_id: sessionId, peer_id: peerId },
+					},
+				},
+			);
+			if (error) err(error);
+			return data!;
+		},
+		enabled: Boolean(workspaceId) && Boolean(sessionId) && Boolean(peerId),
+	});
+}
+
+export function useSetPeerConfig(workspaceId: string, sessionId: string, peerId: string) {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async (config: Record<string, unknown>) => {
+			const { data, error } = await client.current.PUT(
+				"/v3/workspaces/{workspace_id}/sessions/{session_id}/peers/{peer_id}/config",
+				{
+					params: {
+						path: { workspace_id: workspaceId, session_id: sessionId, peer_id: peerId },
+					},
+					body: config,
+				},
+			);
+			if (error) err(error);
+			return data!;
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: QK.peerConfig(workspaceId, sessionId, peerId) });
+		},
+	});
+}
+
+// ─── Session summaries & context ──────────────────────────────────────────────
+
 export function useSessionSummaries(workspaceId: string, sessionId: string) {
 	return useQuery({
-		queryKey: ["session-summaries", workspaceId, sessionId],
+		queryKey: QK.sessionSummaries(workspaceId, sessionId),
 		queryFn: async () => {
 			const { data, error } = await client.current.GET(
 				"/v3/workspaces/{workspace_id}/sessions/{session_id}/summaries",
-				{
-					params: { path: { workspace_id: workspaceId, session_id: sessionId } },
-				},
+				{ params: { path: { workspace_id: workspaceId, session_id: sessionId } } },
 			);
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 		enabled: Boolean(workspaceId) && Boolean(sessionId),
 	});
@@ -264,16 +617,14 @@ export function useSessionSummaries(workspaceId: string, sessionId: string) {
 
 export function useSessionContext(workspaceId: string, sessionId: string) {
 	return useQuery({
-		queryKey: ["session-context", workspaceId, sessionId],
+		queryKey: QK.sessionContext(workspaceId, sessionId),
 		queryFn: async () => {
 			const { data, error } = await client.current.GET(
 				"/v3/workspaces/{workspace_id}/sessions/{session_id}/context",
-				{
-					params: { path: { workspace_id: workspaceId, session_id: sessionId } },
-				},
+				{ params: { path: { workspace_id: workspaceId, session_id: sessionId } } },
 			);
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 		enabled: Boolean(workspaceId) && Boolean(sessionId),
 	});
@@ -288,7 +639,7 @@ export function useConclusions(
 	pageSize = 20,
 ) {
 	return useQuery({
-		queryKey: ["conclusions", workspaceId, filters, page, pageSize],
+		queryKey: QK.conclusions(workspaceId, filters, page, pageSize),
 		queryFn: async () => {
 			const { data, error } = await client.current.POST(
 				"/v3/workspaces/{workspace_id}/conclusions/list",
@@ -300,8 +651,8 @@ export function useConclusions(
 					body: filters,
 				},
 			);
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 		enabled: Boolean(workspaceId),
 	});
@@ -314,7 +665,7 @@ export function useQueryConclusions(
 	enabled = false,
 ) {
 	return useQuery({
-		queryKey: ["conclusions-query", workspaceId, query, filters],
+		queryKey: QK.conclusionsQuery(workspaceId, query, filters),
 		queryFn: async () => {
 			const { data, error } = await client.current.POST(
 				"/v3/workspaces/{workspace_id}/conclusions/query",
@@ -323,9 +674,137 @@ export function useQueryConclusions(
 					body: { query, top_k: 10, ...filters },
 				},
 			);
-			if (error) throw new Error(JSON.stringify(error));
-			return data;
+			if (error) err(error);
+			return data!;
 		},
 		enabled: enabled && Boolean(workspaceId) && Boolean(query),
 	});
 }
+
+export function useCreateConclusion(workspaceId: string) {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async (conclusion: {
+			observer_id: string;
+			observed_id: string;
+			content: string;
+			session_id?: string | null;
+		}) => {
+			const { data, error } = await client.current.POST(
+				"/v3/workspaces/{workspace_id}/conclusions",
+				{
+					params: { path: { workspace_id: workspaceId } },
+					body: { conclusions: [conclusion] },
+				},
+			);
+			if (error) err(error);
+			return data!;
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: ["conclusions", workspaceId] });
+		},
+	});
+}
+
+export function useDeleteConclusion(workspaceId: string) {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async (conclusionId: string) => {
+			const { error } = await client.current.DELETE(
+				"/v3/workspaces/{workspace_id}/conclusions/{conclusion_id}",
+				{
+					params: {
+						path: { workspace_id: workspaceId, conclusion_id: conclusionId },
+					},
+				},
+			);
+			if (error) err(error);
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: ["conclusions", workspaceId] });
+			qc.invalidateQueries({ queryKey: ["conclusions-query", workspaceId] });
+		},
+	});
+}
+
+// ─── Webhooks ─────────────────────────────────────────────────────────────────
+
+export function useWebhooks(workspaceId: string) {
+	return useQuery({
+		queryKey: QK.webhooks(workspaceId),
+		queryFn: async () => {
+			const { data, error } = await client.current.GET(
+				"/v3/workspaces/{workspace_id}/webhooks",
+				{ params: { path: { workspace_id: workspaceId } } },
+			);
+			if (error) err(error);
+			return data!;
+		},
+		enabled: Boolean(workspaceId),
+	});
+}
+
+export function useCreateWebhook(workspaceId: string) {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async (url: string) => {
+			const { data, error } = await client.current.POST(
+				"/v3/workspaces/{workspace_id}/webhooks",
+				{
+					params: { path: { workspace_id: workspaceId } },
+					body: { url },
+				},
+			);
+			if (error) err(error);
+			return data!;
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: QK.webhooks(workspaceId) });
+		},
+	});
+}
+
+export function useDeleteWebhook(workspaceId: string) {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: async (endpointId: string) => {
+			const { error } = await client.current.DELETE(
+				"/v3/workspaces/{workspace_id}/webhooks/{endpoint_id}",
+				{
+					params: {
+						path: { workspace_id: workspaceId, endpoint_id: endpointId },
+					},
+				},
+			);
+			if (error) err(error);
+		},
+		onSuccess: () => {
+			qc.invalidateQueries({ queryKey: QK.webhooks(workspaceId) });
+		},
+	});
+}
+
+export function useTestWebhook(workspaceId: string) {
+	return useMutation({
+		mutationFn: async () => {
+			const { data, error } = await client.current.GET(
+				"/v3/workspaces/{workspace_id}/webhooks/test",
+				{ params: { path: { workspace_id: workspaceId } } },
+			);
+			if (error) err(error);
+			return data!;
+		},
+	});
+}
+
+// ─── Keys ─────────────────────────────────────────────────────────────────────
+
+export function useCreateKey() {
+	return useMutation({
+		mutationFn: async () => {
+			const { data, error } = await client.current.POST("/v3/keys", {});
+			if (error) err(error);
+			return data!;
+		},
+	});
+}