feat: fix RAG pipelines, Beep Graph branding, PWA, and ambient glow UI

Pipeline fixes:
- Fix agent getting empty response from graph-rag by combining answer +
  explain data in single message (RequestResponse returns first msg)
- Fix Doc RAG pipeline: add content field to Qdrant doc payload, seed 10
  document chunks, fix type mismatches across base/flow/client
- Forward explainability events from agent's KnowledgeQuery to client
- Add "agent" to TERM_BEARING_RESPONSE_SERVICES for triple translation
- Fix embeddings env var (OLLAMA_URL), user/collection threading, edge
  scoring threshold, and various protocol mismatches

Branding:
- Rename TrustGraph → Beep Graph (title, sidebar, settings, about)
- Custom lambda + ThugLife pixel glasses SVG logo component
- Forest green color palette (brand-50 through brand-900)
- SVG favicon + PNG icons (16/32/180/192/512)
- PWA manifest with service worker for offline shell caching
- Splash screen with animated logo pulse on app load
- Ambient glow background with drifting green radial blobs

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

ts/packages/flow/src/retrieval/document-rag-service.ts

@@ -96,7 +96,7 @@ export class DocumentRagService extends FlowProcessor {
         collection: msg.collection,
       });
 
-      await producer.send(requestId, { response });
+      await producer.send(requestId, { response, endOfStream: true });
     } catch (err) {
       console.error("[DocumentRag] Query failed:", err);
       await producer.send(requestId, {

ts/packages/flow/src/retrieval/document-rag.ts

@@ -13,6 +13,8 @@ import type {
   TextCompletionResponse,
   EmbeddingsRequest,
   EmbeddingsResponse,
+  DocumentEmbeddingsRequest,
+  DocumentEmbeddingsResponse,
   PromptRequest,
   PromptResponse,
 } from "@trustgraph/base";
@@ -20,7 +22,7 @@ import type {
 export interface DocumentRagClients {
   llm: RequestResponse<TextCompletionRequest, TextCompletionResponse>;
   embeddings: RequestResponse<EmbeddingsRequest, EmbeddingsResponse>;
-  docEmbeddings: RequestResponse<unknown, unknown>; // Doc embedding query
+  docEmbeddings: RequestResponse<DocumentEmbeddingsRequest, DocumentEmbeddingsResponse>;
   prompt: RequestResponse<PromptRequest, PromptResponse>;
 }
 
@@ -31,22 +33,31 @@ export class DocumentRag {
 
   async query(
     queryText: string,
-    _options?: {
+    options?: {
       collection?: string;
       streaming?: boolean;
       chunkCallback?: ChunkCallback;
     },
   ): Promise<string> {
+    const collection = options?.collection ?? "default";
+
     // Step 1: Embed the query
     const embResp = await this.clients.embeddings.request({ text: [queryText] });
     const vectors = (embResp as EmbeddingsResponse).vectors;
 
     // Step 2: Find similar document chunks
-    const docResp = await this.clients.docEmbeddings.request({ vectors, limit: 10 });
-    const chunks = docResp as { chunks: Array<{ content: string; document: string }> };
+    const docResp = await this.clients.docEmbeddings.request({
+      vectors,
+      limit: 10,
+      collection,
+      user: "default",
+    });
+    const chunks = (docResp as DocumentEmbeddingsResponse).chunks ?? [];
+    console.log(`[DocumentRag] Found ${chunks.length} matching chunks`);
 
     // Step 3: Build context from chunks
-    const context = (chunks.chunks ?? [])
+    const context = chunks
+      .filter((c) => c.content)
       .map((c) => c.content)
       .join("\n\n---\n\n");
 

ts/packages/flow/src/retrieval/graph-rag-service.ts

@@ -94,6 +94,7 @@ export class GraphRagService extends FlowProcessor {
     if (!requestId) return;
 
     const producer = flowCtx.flow.producer<GraphRagResponse>("graph-rag-response");
+    console.log(`[GraphRagService] Received request ${requestId}: "${msg.query?.slice(0, 60)}..." collection=${msg.collection}`);
 
     try {
       // Create a per-request GraphRag instance with flow clients
@@ -113,11 +114,27 @@ export class GraphRagService extends FlowProcessor {
         },
       );
 
-      const response = await graphRag.query(msg.query, {
+      const result = await graphRag.query(msg.query, {
         collection: msg.collection,
       });
 
-      await producer.send(requestId, { response });
+      // Send answer with explain data embedded in a SINGLE message.
+      // Non-streaming callers (agent's RequestResponse) return the first
+      // response — so the answer must be in that first (and only) message.
+      // Streaming callers (gateway) extract explain data + answer from
+      // the same message.
+      const response: GraphRagResponse = {
+        response: result.answer,
+        endOfStream: true,
+      };
+
+      if (result.subgraph.length > 0) {
+        (response as Record<string, unknown>).message_type = "explain";
+        (response as Record<string, unknown>).explain_id = `explain-${requestId}`;
+        (response as Record<string, unknown>).explain_triples = result.subgraph;
+      }
+
+      await producer.send(requestId, response);
     } catch (err) {
       console.error("[GraphRag] Query failed:", err);
       await producer.send(requestId, {

ts/packages/flow/src/retrieval/graph-rag.ts

@@ -46,6 +46,11 @@ export interface GraphRagClients {
 
 export type ChunkCallback = (text: string, endOfStream: boolean) => Promise<void>;
 
+export interface GraphRagResult {
+  answer: string;
+  subgraph: Triple[];
+}
+
 export class GraphRag {
   private config: Required<GraphRagConfig>;
 
@@ -58,7 +63,7 @@ export class GraphRag {
       tripleLimit: config.tripleLimit ?? 30,
       maxSubgraphSize: config.maxSubgraphSize ?? 1000,
       maxPathLength: config.maxPathLength ?? 2,
-      edgeScoreLimit: config.edgeScoreLimit ?? 30,
+      edgeScoreLimit: config.edgeScoreLimit ?? 50,
       edgeLimit: config.edgeLimit ?? 25,
     };
   }
@@ -70,28 +75,39 @@ export class GraphRag {
       streaming?: boolean;
       chunkCallback?: ChunkCallback;
     },
-  ): Promise<string> {
+  ): Promise<GraphRagResult> {
+    console.log(`[GraphRag] Query: "${queryText.slice(0, 80)}..."`);
+
     // Step 1: Extract concepts from the query via prompt + LLM
     const concepts = await this.extractConcepts(queryText);
+    console.log(`[GraphRag] Step 1: extracted ${concepts.length} concepts: ${concepts.slice(0, 5).join(", ")}`);
 
     // Step 2: Embed concepts concurrently
     const vectors = await this.getVectors(concepts);
+    console.log(`[GraphRag] Step 2: got ${vectors.length} vectors (dim=${vectors[0]?.length ?? 0})`);
 
     // Step 3: Find matching entities via graph embeddings
-    const entities = await this.getEntities(vectors);
+    const entities = await this.getEntities(vectors, options?.collection);
+    console.log(`[GraphRag] Step 3: found ${entities.length} matching entities`);
 
     // Step 4: Traverse the knowledge graph from entities
-    const subgraph = await this.followEdges(entities);
+    const subgraph = await this.followEdges(entities, options?.collection);
+    console.log(`[GraphRag] Step 4: traversed graph, ${subgraph.length} triples in subgraph`);
 
     // Step 5: Score and filter edges via LLM
     const scoredEdges = await this.scoreEdges(queryText, subgraph);
+    console.log(`[GraphRag] Step 5: scored down to ${scoredEdges.length} edges`);
 
     // Step 6: Synthesize answer
-    return await this.synthesize(
+    console.log(`[GraphRag] Step 6: synthesizing answer from ${scoredEdges.length} edges...`);
+    const answer = await this.synthesize(
       queryText,
       scoredEdges,
-      options?.chunkCallback
+      options?.chunkCallback,
     );
+    console.log(`[GraphRag] Step 6: done (${answer.length} chars)`);
+
+    return { answer, subgraph: scoredEdges };
   }
 
   private async extractConcepts(query: string): Promise<string[]> {
@@ -117,15 +133,17 @@ export class GraphRag {
     return (resp as EmbeddingsResponse).vectors;
   }
 
-  private async getEntities(vectors: number[][]): Promise<Term[]> {
+  private async getEntities(vectors: number[][], collection?: string): Promise<Term[]> {
     const resp = await this.clients.graphEmbeddings.request({
       vectors,
+      user: "default",
+      collection: collection ?? "default",
       limit: this.config.entityLimit,
     });
     return (resp as GraphEmbeddingsResponse).entities;
   }
 
-  private async followEdges(entities: Term[]): Promise<Triple[]> {
+  private async followEdges(entities: Term[], collection?: string): Promise<Triple[]> {
     // BFS multi-hop traversal up to maxPathLength
     const visited = new Set<string>();
     const subgraph: Triple[] = [];
@@ -150,6 +168,7 @@ export class GraphRag {
         const term = stringToTerm(entityStr);
         return this.clients.triples.request({
           s: term,
+          collection,
           limit: this.config.tripleLimit,
         });
       });
@@ -192,7 +211,9 @@ export class GraphRag {
     if (triples.length === 0) return [];
 
     // If the subgraph is small enough, skip LLM scoring entirely
-    if (triples.length <= this.config.edgeLimit) {
+    // 500 triples is well within LLM context limits and avoids lossy scoring
+    if (triples.length <= 500) {
+      console.log(`[GraphRag] Skipping edge scoring — ${triples.length} triples fits in context directly`);
       return triples;
     }
 
@@ -224,6 +245,7 @@ export class GraphRag {
     });
 
     const responseText = (llmResp as TextCompletionResponse).response;
+    console.log(`[GraphRag] Edge scoring LLM response (first 500 chars): ${responseText.slice(0, 500)}`);
 
     // Parse scores from LLM response
     // Expected format: JSON array of { id: string, score: number }
@@ -270,6 +292,8 @@ export class GraphRag {
       }
     }
 
+    console.log(`[GraphRag] Edge scoring: LLM returned ${scored.length} scores, keeping top ${topN.length}, mapped ${result.length} triples`);
+
     // If scoring failed entirely, fall back to returning the first edgeLimit triples
     if (result.length === 0) {
       return triples.slice(0, this.config.edgeLimit);