portals-mcp 1.2.2 → 1.2.3-beta.1

package/dist/api.js

@@ -192,6 +192,25 @@ export async function sendUserMessage(content, roomId) {
     });
     await parseJsonResponse(res, "Failed to send user message");
 }
+export async function uploadAudio(roomId, fileData, fileType) {
+    const res = await fetch(`${API_BASE}/api/v2/utils/generate-audio-upload-url`, {
+        method: "POST",
+        body: JSON.stringify({ fileType, roomId }),
+        headers: {
+            "Content-Type": "application/json",
+            "x-api-key": getAccessKey(),
+        },
+    });
+    const json = await parseJsonResponse(res, "Failed to generate audio upload URL");
+    const putRes = await fetch(json.signedUploadURL, {
+        method: "PUT",
+        headers: { "Content-Type": fileType },
+        body: fileData,
+    });
+    if (!putRes.ok)
+        throw new Error(`Failed to upload audio: ${putRes.statusText}`);
+    return { assetURL: json.assetURL, objectKey: json.objectKey };
+}
 export async function downloadRoomData(roomId) {
     const res = await fetch(`${API_BASE}/api/v2/mcp/download-room-data`, {
         method: "GET",

package/dist/context-assembler.js

@@ -0,0 +1,199 @@
+/**
+ * Context assembler — powers the get_context tool.
+ *
+ * Uses the existing intent-matching engine from context-recommend.ts
+ * to identify relevant resources, then reads them from disk and returns
+ * the content inline (instead of returning URIs for the agent to read).
+ */
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { recommendContextForTask } from "./context-recommend.js";
+import { resolveDocsRoot, docsRootCandidates } from "./docs.js";
+import { searchBundledRecipes } from "./recipe-search.js";
+import { tokenizeQuery } from "./utils.js";
+// Map intent IDs to pitfall categories
+const INTENT_TO_PITFALL_CATEGORIES = {
+    "js-scripting": ["js", "javascript", "functioneffectorjs", "variables", "strings"],
+    "function-effects": ["ncalc", "functioneffector", "expressions", "variables", "quests", "tasks"],
+    "gameplay-build": ["quests", "tasks", "variables", "interactions"],
+    "scene-item": ["items", "fields", "naming"],
+    "scene-design": ["items", "placement", "coordinates"],
+    "create-room": ["room", "settings"],
+    "settings-update": ["settings"],
+    "asset-pipeline": ["assets", "glb", "upload"],
+};
+async function loadPitfalls() {
+    const docsRoot = resolveDocsRoot();
+    if (!docsRoot)
+        return [];
+    const pitfallsPath = resolve(docsRoot, "ref", "pitfalls.json");
+    if (!existsSync(pitfallsPath))
+        return [];
+    try {
+        const raw = JSON.parse(await readFile(pitfallsPath, "utf-8"));
+        // pitfalls.json has a "pitfalls" array
+        if (Array.isArray(raw.pitfalls))
+            return raw.pitfalls;
+        if (Array.isArray(raw))
+            return raw;
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+function filterPitfalls(pitfalls, intents) {
+    const relevantCategories = new Set();
+    for (const intent of intents) {
+        const categories = INTENT_TO_PITFALL_CATEGORIES[intent];
+        if (categories) {
+            for (const cat of categories)
+                relevantCategories.add(cat);
+        }
+    }
+    // If no category mapping, return top pitfalls as general guidance
+    if (relevantCategories.size === 0) {
+        return pitfalls.slice(0, 5).map(pitfallToGotcha);
+    }
+    const filtered = pitfalls.filter((p) => {
+        if (!p.categories || p.categories.length === 0)
+            return true; // uncategorized = always relevant
+        return p.categories.some((c) => relevantCategories.has(c.toLowerCase()));
+    });
+    return filtered.map(pitfallToGotcha);
+}
+function pitfallToGotcha(p) {
+    const gotcha = { rule: p.rule, detail: p.detail };
+    if (p.wrong)
+        gotcha.wrong = p.wrong;
+    if (p.right)
+        gotcha.right = p.right;
+    return gotcha;
+}
+// ── Resource reading ──
+async function readResourceContent(uri) {
+    const docsRoot = resolveDocsRoot();
+    if (!docsRoot)
+        return null;
+    // docs://ref/systems/function-effector → ref/systems/function-effector
+    const stripped = uri.replace(/^docs:\/\//, "");
+    // Try common extensions
+    const extensions = [".json", ".md", ".txt", ".py"];
+    const roots = docsRootCandidates();
+    for (const root of roots) {
+        if (!existsSync(root))
+            continue;
+        for (const ext of extensions) {
+            const fullPath = resolve(root, stripped + ext);
+            if (existsSync(fullPath)) {
+                try {
+                    return await readFile(fullPath, "utf-8");
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        // Try without extension (file might already have one in the URI)
+        const directPath = resolve(root, stripped);
+        if (existsSync(directPath)) {
+            try {
+                return await readFile(directPath, "utf-8");
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return null;
+}
+// ── Main assembly ──
+export async function assembleContext(query, options) {
+    // 1. Score intents using existing engine
+    const recommendOpts = { maxIntents: 3 };
+    if (options?.stage)
+        recommendOpts.stage = options.stage;
+    const recommendation = recommendContextForTask(query, recommendOpts);
+    const matchedIntents = recommendation.selected_intents.map((i) => i.intent);
+    // 2. Collect resource URIs to read (required + recommended, skip deep_dive)
+    const resourcesToRead = [
+        ...recommendation.resource_phases.required,
+        ...recommendation.resource_phases.recommended,
+    ];
+    // Deduplicate URIs
+    const uniqueUris = [...new Set(resourcesToRead.map((r) => r.uri))];
+    // 3. Read resource content in parallel
+    const contentParts = [];
+    const readPromises = uniqueUris.map(async (uri) => {
+        const content = await readResourceContent(uri);
+        if (content) {
+            return { uri, content };
+        }
+        return null;
+    });
+    const results = await Promise.all(readPromises);
+    for (const result of results) {
+        if (result) {
+            contentParts.push(result.content);
+        }
+    }
+    // 4. Filter pitfalls to relevant gotchas
+    const allPitfalls = await loadPitfalls();
+    const gotchas = filterPitfalls(allPitfalls, matchedIntents);
+    // 5. Search recipes
+    const tokens = tokenizeQuery(query);
+    let recipes = [];
+    try {
+        const recipeResults = await searchBundledRecipes(query, { top: 5 });
+        recipes = recipeResults.matches.map((r) => ({
+            name: r.name,
+            summary: r.summary,
+            patterns: r.patterns,
+            uri: r.resource_uri,
+        }));
+    }
+    catch {
+        // Non-critical
+    }
+    // 6. Build task summary
+    const taskSummary = buildTaskSummary(matchedIntents, query);
+    // 7. Collect deep-dive URIs (not read inline, available for agents that want more)
+    const deepDiveUris = recommendation.resource_phases.deep_dive.map((r) => r.uri);
+    // 8. Collect suggested tools
+    const suggestedTools = recommendation.tool_sequence.map((t) => t.tool);
+    return {
+        task_summary: taskSummary,
+        matched_intents: matchedIntents,
+        knowledge: contentParts.join("\n\n---\n\n"),
+        gotchas,
+        relevant_recipes: recipes,
+        deep_dive_uris: deepDiveUris,
+        suggested_tools: suggestedTools,
+    };
+}
+function buildTaskSummary(intents, query) {
+    const descriptions = {
+        "setup-auth": "Setting up authentication and connection",
+        "create-room": "Creating a new room",
+        "scene-item": "Working with scene items and placement",
+        "gameplay-build": "Building gameplay mechanics",
+        "function-effects": "Implementing logic with NCalc expressions",
+        "js-scripting": "Building with JavaScript/FunctionEffectorJS",
+        "logic-board": "Creating a logic board / flowchart",
+        "local-scripting": "Using Python tools for room generation",
+        "validation-publish": "Validating and publishing",
+        "asset-pipeline": "Uploading and managing assets",
+        "settings-update": "Updating room settings",
+        "game-design-full": "Designing and building a complete game",
+        "scene-design": "Designing scene composition and layout",
+        "room-targeting": "Working with an existing room",
+    };
+    const parts = intents
+        .map((i) => descriptions[i])
+        .filter(Boolean);
+    if (parts.length === 0) {
+        return `Task: ${query}`;
+    }
+    return parts.join(" + ");
+}

package/dist/docs.js

@@ -2,7 +2,6 @@ import { existsSync, readdirSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { markResourceRead } from "./context-handshake.js";
 import { isWithinRoot } from "./utils.js";
 const SUPPORTED_RESOURCE_EXTENSIONS = [".md", ".json", ".py", ".txt"];
 const STATIC_DOC_RESOURCES = [
@@ -108,22 +107,6 @@ const STATIC_DOC_RESOURCES = [
         mimeType: "text/markdown",
     },
     // ── Workflows ────────────────────────────────────────────────────
-    {
-        name: "docs_workflow_builder",
-        uri: "docs://workflows/builder",
-        title: "Builder Workflow",
-        description: "Build and iteration workflow for approved game designs.",
-        relativePath: "workflows/builder.md",
-        mimeType: "text/markdown",
-    },
-    {
-        name: "docs_workflow_game_designer",
-        uri: "docs://workflows/game-designer",
-        title: "Game Designer Workflow",
-        description: "Discovery, design doc creation, and approval flow.",
-        relativePath: "workflows/game-designer.md",
-        mimeType: "text/markdown",
-    },
     {
         name: "docs_workflow_quality_review",
         uri: "docs://workflows/quality-review",
@@ -148,12 +131,10 @@ const HELP_TOPICS = [
         title: "System Overview",
         summary: "Start here for AI-native contracts and minimal context loading.",
         steps: [
-            "Read docs://ai/bootstrap first.",
-            "Read docs://ai/contracts/tool-output-envelope to parse all tool outputs safely.",
-            "Use recommend_context for task-specific resource selection.",
-            "Read context_handshake.required_resources before mutating tools.",
-            "Use context_handshake.token as contextToken on mutating tool calls.",
+            "Call get_context with a description of what you want to build — it returns inline specs, gotchas, and recipes.",
+            "Use lookup(term) for quick spec lookups on specific items, triggers, or effects.",
             "Use docs://usage-rules when wiring read/write workflows.",
+            "Read docs://ai/contracts/tool-output-envelope to parse all tool outputs safely.",
         ],
         resources: [
             "docs://ai/bootstrap",
@@ -168,12 +149,11 @@ const HELP_TOPICS = [
         title: "Validate Room Workflow",
         summary: "Run validation before merge/upload and resolve structured errors.",
         steps: [
-            "Use recommend_context with your task to retrieve minimal validation resources.",
-            "Read required resources and include contextToken on mutation calls.",
-            "Use docs://workflows/validate-room as the quality checklist.",
+            "Call get_context with your validation task for relevant context.",
+            "Use run_python_tool with validate_room to check the room snapshot.",
             "After set_room_data, re-read room data and verify expected counts.",
         ],
-        resources: ["docs://workflows/validate-room", "docs://usage-rules"],
+        resources: ["docs://usage-rules", "docs://reference/gotchas"],
         aliases: ["validate", "quality", "validation"],
     },
     {
@@ -181,15 +161,12 @@ const HELP_TOPICS = [
         title: "Design + Build Flow",
         summary: "Use the standardized sequence to maximize quality and consistency.",
         steps: [
-            "Call recommend_context with your requested mechanic list before loading docs.",
-            "Follow docs://workflows/game-designer for discovery and design approval.",
-            "Follow docs://workflows/builder for implementation and iteration.",
-            "Use docs://recipes/manifest for known mechanics.",
+            "Call get_context with your game concept for targeted specs, gotchas, and recipe matches.",
+            "Use search_recipes to find known mechanics before building from scratch.",
             "Use lookup tool for specific item/trigger/effect specs.",
         ],
         resources: [
-            "docs://workflows/game-designer",
-            "docs://workflows/builder",
+            "docs://workflows/builder-workflow",
             "docs://ref/systems/function-effector",
             "docs://recipes/manifest",
         ],
@@ -231,12 +208,11 @@ const HELP_TOPICS = [
         title: "Asset Upload Workflow",
         summary: "Upload GLB/image assets with MCP tools and keep returned URLs in context.",
         steps: [
-            "Use recommend_context with stage=assets for minimal resource loading.",
-            "Use upload_glb or upload_glbs_from_folder for model assets.",
-            "Use upload_image or upload_images_from_folder for image assets.",
+            "Use upload_glb for model assets (supports single file or folder).",
+            "Use upload_image for image assets (supports single file or folder).",
             "Persist returned asset URLs before applying room data updates.",
         ],
-        resources: ["docs://workflows/asset-pipeline", "docs://usage-rules"],
+        resources: ["docs://usage-rules"],
         aliases: ["glb", "images", "upload", "cdn"],
     },
     {
@@ -277,7 +253,7 @@ const HELP_TOPICS = [
             "Normalize non-standard input: use sentiment_map for words, out_of_range for numbers > 5.",
             "Branch: high (4-5) → ask what stood out, mid (3) → ask what would improve it, low (1-2) → ask what went wrong and offer to iterate.",
             "Use canonical tags: positive (great-layout, good-mechanics, nice-visuals, good-audio, matched-vision, fun-to-play) or negative (wrong-layout, missing-mechanic, wrong-recipe, needs-polish, missing-audio, too-hard, too-easy, confusing, incomplete, performance).",
-            "Call rate_build with contextToken, rating, tags, optional aspects (Match, Polish, Completeness), and comment.",
+            "Call rate_build with rating, tags, optional aspects (Match, Polish, Completeness), and comment.",
         ],
         resources: ["docs://usage-rules", "docs://guide/workflow-steps"],
         aliases: ["rate", "rating", "review"],
@@ -287,11 +263,9 @@ const HELP_TOPICS = [
         title: "Context Selection",
         summary: "Load high-signal resources in stable order to reduce token usage.",
         steps: [
-            "Load docs://ai/bootstrap first.",
+            "Call get_context with your task description for targeted inline knowledge.",
             "Use the lookup tool for specific item/trigger/effect specs (~100 tokens each).",
-            "Call recommend_context for broader task-specific resource selection.",
             "Read docs://index/knowledge-map to navigate all available content.",
-            "Load priority-2 resources from recommend_context when task details are ambiguous.",
             "Avoid loading full snapshots unless condensed summaries are insufficient.",
         ],
         resources: [
@@ -558,7 +532,6 @@ export function registerDocsResources(server) {
         description: "Machine-readable JSON catalog of all docs:// resources exposed by this server.",
         mimeType: "application/json",
     }, async (uri) => {
-        markResourceRead(uri.toString());
         return {
             contents: [
                 {
@@ -575,7 +548,6 @@ export function registerDocsResources(server) {
             description: resource.description,
             mimeType: resource.mimeType,
         }, async (uri) => {
-            markResourceRead(uri.toString());
             const text = await readDocResource(resource);
             return {
                 contents: [

package/dist/feedback-prompts.js

@@ -1,15 +1,15 @@
-export function buildSceneRefinementPrompt(contextToken, roomId, filePath, mode) {
+export function buildSceneRefinementPrompt(sessionId, roomId, filePath, mode) {
     if (mode === "full") {
         return {
             required_action: true,
             action: "scene_refinement_loop",
-            instruction: "Before collecting a push rating, you MUST run the scene refinement loop. " +
+            instruction: "You MUST run the scene refinement loop. " +
                 "Call analyze_scene with the snapshot file path. Review the check results. " +
                 "For each failed check, apply the suggested corrections via apply_operations. " +
                 "Then ask the user: 'Would you like another scene review pass?' " +
                 "If yes, call analyze_scene again and repeat. " +
-                "If no (or all checks pass), proceed to collect the push rating.",
-            context_token: contextToken,
+                "If no (or all checks pass), proceed.",
+            session_id: sessionId,
             room_id: roomId,
             file_path: filePath,
             convergence: {
@@ -26,95 +26,9 @@ export function buildSceneRefinementPrompt(contextToken, roomId, filePath, mode)
             "Call analyze_scene with focus.objectIds set to the IDs of modified/added items. " +
             "Review any failed checks related to those items and apply fixes if needed. " +
             "This is a single-pass review, not an iterative loop.",
-        context_token: contextToken,
+        session_id: sessionId,
         room_id: roomId,
         file_path: filePath,
         submit_via: "analyze_scene",
     };
 }
-export function buildPushRatingPrompt(contextToken, roomId, pushInfo) {
-    return {
-        required_action: true,
-        action: "collect_push_rating",
-        instruction: "You MUST ask the user this question and wait for their response before calling rate_push. " +
-            "Do NOT self-assess or guess — the rating must come from the user. " +
-            "If the user declines or ignores, say 'No problem!' and move on without calling rate_push.",
-        context_token: contextToken ?? null,
-        room_id: roomId,
-        phase_number: pushInfo.phaseNumber,
-        push_in_phase: pushInfo.pushCountInPhase,
-        total_pushes: pushInfo.pushCountInSession,
-        script: {
-            prompt: "Quick check — on a scale of 1-5, how did this update land? (Feel free to add any comments too)",
-            scale_labels: {
-                "1": "Poor",
-                "2": "Below expectations",
-                "3": "Decent",
-                "4": "Good",
-                "5": "Nailed it",
-            },
-            after_rating: "If they want more changes, use phase_trigger on the next push. If they're satisfied, call rate_build for the overall session rating.",
-        },
-        submit_via: "rate_push",
-    };
-}
-export function buildSessionRatingPrompt(contextToken, roomId) {
-    return {
-        trigger: "after_user_tests_build",
-        context_token: contextToken ?? null,
-        room_id: roomId,
-        script: {
-            opening: "Nice work testing the build! I'd love to hear how it turned out.",
-            rating_question: "On a quick scale of 1-5, how did this build land for you?",
-            scale_labels: {
-                "1": "Poor — major issues",
-                "2": "Below expectations",
-                "3": "Decent — works but needs improvement",
-                "4": "Good — close to what I wanted",
-                "5": "Excellent — nailed it",
-            },
-            followup_high: "Awesome! Anything that stood out? I'll tag the highlights so future builds keep that quality.",
-            followup_mid: "Got it. What would push this from a 3 to a 5? I can note the specific areas.",
-            followup_low: "Sorry about that. Was it the layout, the mechanics, missing features, or something else? I want to capture what needs fixing and can take another pass.",
-            closing: "Thanks for the feedback — it helps the system get smarter at building.",
-        },
-        tag_vocabulary: {
-            positive: [
-                { tag: "great-layout", meaning: "Spatial design felt right" },
-                { tag: "good-mechanics", meaning: "Mechanics were fun and worked" },
-                { tag: "nice-visuals", meaning: "Lighting and visual polish were strong" },
-                { tag: "good-audio", meaning: "Sound enhanced the experience" },
-                { tag: "matched-vision", meaning: "Build matched what was described" },
-                { tag: "fun-to-play", meaning: "Overall experience was enjoyable" },
-            ],
-            negative: [
-                { tag: "wrong-layout", meaning: "Items misplaced, floating, or poorly arranged" },
-                { tag: "missing-mechanic", meaning: "A requested mechanic was absent or broken" },
-                { tag: "wrong-recipe", meaning: "Wrong approach or pattern for a mechanic" },
-                { tag: "needs-polish", meaning: "Functional but rough" },
-                { tag: "missing-audio", meaning: "Sound effects or ambient audio absent" },
-                { tag: "too-hard", meaning: "Difficulty too high" },
-                { tag: "too-easy", meaning: "Not enough challenge" },
-                { tag: "confusing", meaning: "Unclear what to do" },
-                { tag: "incomplete", meaning: "Build felt unfinished" },
-                { tag: "performance", meaning: "Lag or too many objects" },
-            ],
-        },
-        normalization: {
-            out_of_range: "Map to 1-5: 0/negative→1, 6-7→4, 8-10→5. Percentages proportionally.",
-            sentiment_map: {
-                terrible: 1, awful: 1, hate: 1,
-                bad: 2, disappointing: 2, meh: 2,
-                okay: 3, fine: 3, decent: 3, alright: 3,
-                good: 4, nice: 4, solid: 4, "pretty good": 4,
-                amazing: 5, perfect: 5, "love it": 5, excellent: 5, awesome: 5, great: 5,
-            },
-            non_numeric: "Map sentiment to closest rating, confirm with user: 'Sounds like a 4/5 — does that feel right?'",
-        },
-        aspects: {
-            accuracy: "Match — did this match what you asked for?",
-            quality: "Polish — does it look and feel good?",
-            completeness: "Completeness — is anything missing?",
-        },
-    };
-}

package/dist/index.js

@@ -60,7 +60,7 @@ async function main() {
     }
     // Initialize intelligence service in the background (non-blocking)
     initIntelligence().catch(() => {
-        // Intelligence init failed — recommend_context falls back to keyword matching
+        // Intelligence init failed — get_context falls back to keyword matching
     });
     // Start WebSocket bridge for browser communication
     startBridge();

package/dist/intelligence-bridge.js

@@ -95,7 +95,21 @@ export async function ensureIntelligence() {
     })();
     return retryInFlight;
 }
-export function shutdownIntelligence() {
+export function shutdownIntelligence(activeSessionIds) {
+    // Close any open sessions before shutting down
+    if (initialized && activeSessionIds) {
+        for (const sessionId of activeSessionIds) {
+            try {
+                // endSession auto-computes avg confidence from ai_feedback
+                endSession(sessionId);
+                triggerRetrievalLearning();
+                uploadSessionTrace(sessionId);
+            }
+            catch {
+                // Best-effort — shutting down
+            }
+        }
+    }
     initialized = false;
 }
 // ── Search (blocking) ──
@@ -152,7 +166,7 @@ export function markSessionCompleted(sessionId) {
 export function endSession(sessionId, feedback) {
     if (!initialized)
         return;
-    fireAndForget(`/sessions/${sessionId}/end`, feedback);
+    fireAndForget(`/sessions/${sessionId}/end`, feedback ?? {});
 }
 // ── Steps (fire-and-forget) ──
 export function recordStep(sessionId, step) {
@@ -244,17 +258,17 @@ export function recordPushToPhase(phaseId) {
         return;
     fireAndForget(`/phases/${phaseId}/push`, {});
 }
-// ── Push ratings ──
-export function ratePush(sessionId, opts) {
+// ── AI feedback ──
+export function recordAiFeedback(sessionId, feedback) {
     if (!initialized)
         return;
-    fireAndForget(`/sessions/${sessionId}/push-ratings`, opts);
+    fireAndForget(`/sessions/${sessionId}/ai-feedback`, feedback);
 }
-export async function getPushRatings(sessionId) {
+export async function getAiFeedback(sessionId) {
     if (!initialized)
         return [];
     try {
-        return await httpGet(`/sessions/${sessionId}/push-ratings`);
+        return await httpGet(`/sessions/${sessionId}/ai-feedback`);
     }
     catch {
         return [];
@@ -293,11 +307,14 @@ export function uploadSessionTrace(sessionId) {
     Promise.all([
         getSession(sessionId),
         getPhases(sessionId),
-        getPushRatings(sessionId),
+        getAiFeedback(sessionId),
     ])
-        .then(([session, phases, pushRatings]) => {
+        .then(([session, phases, aiFeedback]) => {
         if (!session || session.rating == null)
             return;
+        // Aggregate doc gaps and recipe requests across all feedback entries
+        const allDocGaps = aiFeedback.flatMap((f) => f.docGaps);
+        const allRecipeRequests = aiFeedback.flatMap((f) => f.recipeRequests);
         // Build a simplified anonymized trace from available data
         const trace = {
             contributorId: getContributorId(),
@@ -311,8 +328,10 @@ export function uploadSessionTrace(sessionId) {
             contextSignals: [],
             toolSequence: [],
             phaseCount: phases.length,
-            pushRatings: pushRatings.map((pr) => pr.rating),
-            schemaVersion: 1,
+            pushConfidences: aiFeedback.map((f) => f.confidence),
+            docGaps: [...new Set(allDocGaps)],
+            recipeRequests: [...new Set(allRecipeRequests)],
+            schemaVersion: 2,
         };
         uploadTrace(trace);
     })

package/dist/lookup.js

@@ -1,6 +1,5 @@
 import { readFile, readdir, stat } from "node:fs/promises";
 import { join, extname, relative } from "node:path";
-import { markResourceRead } from "./context-handshake.js";
 const index = [];
 let initialized = false;
 function normalizeKey(value) {
@@ -228,7 +227,6 @@ export function performLookup(term, category, type) {
         const readUris = new Set();
         for (const entry of matches) {
             if (!readUris.has(entry.uri)) {
-                markResourceRead(entry.uri);
                 readUris.add(entry.uri);
             }
         }
@@ -260,7 +258,6 @@ export function performLookup(term, category, type) {
     });
     if (exactMatches.length > 0) {
         for (const entry of exactMatches) {
-            markResourceRead(entry.uri);
         }
         return {
             match_type: "exact",
@@ -289,7 +286,6 @@ export function performLookup(term, category, type) {
     })
         .slice(0, 5);
     for (const entry of fuzzyMatches) {
-        markResourceRead(entry.uri);
     }
     return {
         match_type: "fuzzy",