@metamask/client-mcp-core 0.1.0

package/dist/mcp-server/knowledge-store.mjs

@@ -0,0 +1,1154 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _KnowledgeStore_instances, _KnowledgeStore_knowledgeRoot, _KnowledgeStore_sessionIdPrefix, _KnowledgeStore_toolPrefix, _KnowledgeStore_sessionMetadataCache, _KnowledgeStore_actionableTools, _KnowledgeStore_toolActionMap, _KnowledgeStore_discoveryTools, _KnowledgeStore_readSessionMetadata, _KnowledgeStore_matchesFilters, _KnowledgeStore_computeLabels, _KnowledgeStore_stepMatchesFilters, _KnowledgeStore_loadSessionSteps, _KnowledgeStore_sanitizeInput, _KnowledgeStore_getEnvironmentInfo, _KnowledgeStore_summarizeStep, _KnowledgeStore_generateSnippet, _KnowledgeStore_generateStepNotes, _KnowledgeStore_computeSessionScore, _KnowledgeStore_computeSearchScore, _KnowledgeStore_getRelatedSessions, _KnowledgeStore_getSimilarSteps, _KnowledgeStore_lookupA11yHint, _KnowledgeStore_computeSimilarityScore, _KnowledgeStore_buildSuggestedActions, _KnowledgeStore_buildPreferredTarget, _KnowledgeStore_buildFallbackTargets, _KnowledgeStore_toolToAction, _KnowledgeStore_buildAvoidList;
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable id-length */
+import { promises as fs } from "fs";
+import * as path from "path";
+import { expandWithSynonyms, tokenize, tokenizeIdentifier } from "./tokenization.mjs";
+import { generateFilesafeTimestamp, isSensitiveField, SENSITIVE_FIELD_PATTERNS, debugWarn } from "./utils/index.mjs";
+const KNOWLEDGE_ROOT = 'test-artifacts/llm-knowledge';
+const SCHEMA_VERSION = 1;
+const PRIOR_KNOWLEDGE_CONFIG = {
+    /** Look back 48 hours for related sessions - balances recency with having enough data */
+    windowHours: 48,
+    /** Limit to 5 related sessions to keep context focused and token-efficient */
+    maxRelatedSessions: 5,
+    /** Maximum 10 similar steps to include - prevents overwhelming the context */
+    maxSimilarSteps: 10,
+    /** Limit to 5 suggested actions to keep recommendations focused and actionable */
+    maxSuggestedActions: 5,
+    /** Maximum 5 items in avoid list to prevent excessive warnings */
+    maxAvoid: 5,
+    /** Require at least 2 failures before suggesting avoidance - prevents false positives */
+    minAvoidFailureCount: 2,
+};
+const SCAN_LIMITS = {
+    /** Scan up to 20 sessions to balance thoroughness with performance */
+    maxSessionsToScan: 20,
+    /** Limit to 500 steps per session to avoid memory issues with large sessions */
+    maxStepsPerSession: 500,
+    /** Hard limit of 2000 total steps across all sessions to prevent excessive scanning */
+    maxTotalSteps: 2000,
+};
+const SIMILARITY_WEIGHTS = {
+    /** Highest weight - same screen is the strongest indicator of relevance */
+    sameScreen: 8,
+    /** URL path overlap indicates similar context/feature area */
+    urlPathOverlap: 6,
+    /** Test ID overlap shows similar UI elements are present */
+    testIdOverlap: 3,
+    /** Accessibility node overlap provides additional context matching */
+    a11yOverlap: 2,
+    /** Actionable tools (click, type, etc.) are more relevant than discovery tools */
+    actionableTool: 2,
+};
+const MAX_SIMILARITY_SCORE = SIMILARITY_WEIGHTS.sameScreen +
+    SIMILARITY_WEIGHTS.urlPathOverlap +
+    SIMILARITY_WEIGHTS.testIdOverlap * 3 +
+    SIMILARITY_WEIGHTS.a11yOverlap * 2 +
+    SIMILARITY_WEIGHTS.actionableTool;
+/**
+ * Extract path tokens from URL hash fragment
+ *
+ * @param url - The URL to extract tokens from
+ * @returns Array of path tokens from the hash fragment
+ */
+function extractPathTokens(url) {
+    try {
+        const hashPart = url.split('#')[1] ?? '';
+        return hashPart
+            .split('/')
+            .filter((t) => t.length > 0 && !t.startsWith('0x'));
+    }
+    catch (error) {
+        debugWarn('knowledge-store.extractPathTokens', error);
+        return [];
+    }
+}
+/**
+ * Persistent cross-session knowledge store for recording and querying tool invocations.
+ */
+export class KnowledgeStore {
+    /**
+     * Initialize KnowledgeStore with optional configuration
+     *
+     * @param config - Configuration options for the store
+     */
+    constructor(config = {}) {
+        _KnowledgeStore_instances.add(this);
+        _KnowledgeStore_knowledgeRoot.set(this, void 0);
+        _KnowledgeStore_sessionIdPrefix.set(this, void 0);
+        _KnowledgeStore_toolPrefix.set(this, void 0);
+        _KnowledgeStore_sessionMetadataCache.set(this, new Map());
+        _KnowledgeStore_actionableTools.set(this, void 0);
+        _KnowledgeStore_toolActionMap.set(this, void 0);
+        _KnowledgeStore_discoveryTools.set(this, void 0);
+        __classPrivateFieldSet(this, _KnowledgeStore_knowledgeRoot, config.rootDir ?? path.join(process.cwd(), KNOWLEDGE_ROOT), "f");
+        __classPrivateFieldSet(this, _KnowledgeStore_sessionIdPrefix, config.sessionIdPrefix ?? 'mm-', "f");
+        __classPrivateFieldSet(this, _KnowledgeStore_toolPrefix, config.toolPrefix ?? 'mm', "f");
+        const prefix = __classPrivateFieldGet(this, _KnowledgeStore_toolPrefix, "f");
+        __classPrivateFieldSet(this, _KnowledgeStore_actionableTools, [
+            `${prefix}_click`,
+            `${prefix}_type`,
+            `${prefix}_wait_for`,
+            `${prefix}_navigate`,
+            `${prefix}_wait_for_notification`,
+        ], "f");
+        __classPrivateFieldSet(this, _KnowledgeStore_toolActionMap, {
+            [`${prefix}_click`]: 'click',
+            [`${prefix}_type`]: 'type',
+            [`${prefix}_wait_for`]: 'wait_for',
+            [`${prefix}_navigate`]: 'navigate',
+            [`${prefix}_wait_for_notification`]: 'wait_for_notification',
+        }, "f");
+        __classPrivateFieldSet(this, _KnowledgeStore_discoveryTools, [
+            `${prefix}_describe_screen`,
+            `${prefix}_list_testids`,
+            `${prefix}_accessibility_snapshot`,
+            `${prefix}_get_state`,
+        ], "f");
+    }
+    /**
+     * Write session metadata to disk
+     *
+     * @param metadata - Session metadata to persist
+     * @returns Path to the written metadata file
+     */
+    async writeSessionMetadata(metadata) {
+        const sessionDir = path.join(__classPrivateFieldGet(this, _KnowledgeStore_knowledgeRoot, "f"), metadata.sessionId);
+        await fs.mkdir(sessionDir, { recursive: true });
+        const filepath = path.join(sessionDir, 'session.json');
+        await fs.writeFile(filepath, JSON.stringify(metadata, null, 2));
+        __classPrivateFieldGet(this, _KnowledgeStore_sessionMetadataCache, "f").set(metadata.sessionId, metadata);
+        return filepath;
+    }
+    /**
+     * List sessions with optional filtering and limit
+     *
+     * @param limit - Maximum number of sessions to return
+     * @param filters - Optional filters for sessions
+     * @returns Array of session summaries
+     */
+    async listSessions(limit, filters) {
+        const sessionIds = await this.getAllSessionIds();
+        const sessions = [];
+        for (const sid of sessionIds) {
+            const metadata = await __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_readSessionMetadata).call(this, sid);
+            if (!metadata) {
+                continue;
+            }
+            if (!__classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_matchesFilters).call(this, metadata, filters)) {
+                continue;
+            }
+            sessions.push({
+                metadata,
+                createdAt: new Date(metadata.createdAt),
+            });
+        }
+        sessions.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        return sessions.slice(0, limit).map((s) => ({
+            sessionId: s.metadata.sessionId,
+            createdAt: s.metadata.createdAt,
+            goal: s.metadata.goal,
+            flowTags: s.metadata.flowTags,
+            tags: s.metadata.tags,
+        }));
+    }
+    /**
+     * Resolve session IDs based on scope and filters
+     *
+     * @param scope - Scope for session resolution (current, all, or specific sessionId)
+     * @param currentSessionId - Current session ID for scope resolution
+     * @param filters - Optional filters to apply to sessions
+     * @returns Array of resolved session IDs
+     */
+    async resolveSessionIds(scope, currentSessionId, filters) {
+        if (scope === 'current') {
+            return currentSessionId ? [currentSessionId] : [];
+        }
+        if (typeof scope === 'object' && 'sessionId' in scope) {
+            return [scope.sessionId];
+        }
+        const allIds = await this.getAllSessionIds();
+        if (!filters) {
+            return allIds;
+        }
+        const filtered = [];
+        for (const sid of allIds) {
+            const metadata = await __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_readSessionMetadata).call(this, sid);
+            if (metadata && __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_matchesFilters).call(this, metadata, filters)) {
+                filtered.push(sid);
+            }
+            else if (!metadata) {
+                filtered.push(sid);
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Record a tool execution step with context and artifacts
+     *
+     * @param params - Step recording parameters
+     * @param params.sessionId - Session ID for this step
+     * @param params.toolName - Name of the tool executed
+     * @param params.input - Tool input parameters
+     * @param params.target - Target element information
+     * @param params.outcome - Execution outcome (success/failure)
+     * @param params.observation - Observed state after execution
+     * @param params.durationMs - Execution duration in milliseconds
+     * @param params.screenshotPath - Path to screenshot artifact
+     * @param params.screenshotDimensions - Screenshot dimensions
+     * @param params.screenshotDimensions.width - Screenshot width in pixels
+     * @param params.screenshotDimensions.height - Screenshot height in pixels
+     * @param params.context - Execution context (e2e or prod)
+     * @returns Path to the recorded step file
+     */
+    async recordStep(params) {
+        const timestamp = new Date();
+        const filesafeTimestamp = generateFilesafeTimestamp(timestamp);
+        const sessionDir = path.join(__classPrivateFieldGet(this, _KnowledgeStore_knowledgeRoot, "f"), params.sessionId);
+        const stepsDir = path.join(sessionDir, 'steps');
+        await fs.mkdir(stepsDir, { recursive: true });
+        const sanitizedInput = __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_sanitizeInput).call(this, params.toolName, params.input);
+        const labels = __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_computeLabels).call(this, params.toolName, params.target, params.outcome);
+        const stepRecord = {
+            schemaVersion: SCHEMA_VERSION,
+            timestamp: timestamp.toISOString(),
+            sessionId: params.sessionId,
+            context: params.context,
+            environment: __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_getEnvironmentInfo).call(this),
+            tool: {
+                name: params.toolName,
+                input: sanitizedInput.input,
+                target: params.target,
+                textRedacted: sanitizedInput.textRedacted,
+                textLength: sanitizedInput.textLength,
+            },
+            timing: {
+                durationMs: params.durationMs,
+            },
+            outcome: params.outcome,
+            observation: params.observation,
+            labels,
+        };
+        if (params.screenshotPath) {
+            stepRecord.artifacts = {
+                screenshot: {
+                    path: params.screenshotPath,
+                    width: params.screenshotDimensions?.width,
+                    height: params.screenshotDimensions?.height,
+                },
+            };
+        }
+        const filename = `${filesafeTimestamp}-${params.toolName}.json`;
+        const filepath = path.join(stepsDir, filename);
+        await fs.writeFile(filepath, JSON.stringify(stepRecord, null, 2));
+        return filepath;
+    }
+    /**
+     * Get the last N steps from the knowledge store
+     *
+     * @param n - Number of steps to retrieve
+     * @param scope - Scope for step retrieval (current, all, or specific sessionId)
+     * @param currentSessionId - Current session ID for scope resolution
+     * @param filters - Optional filters to apply to steps
+     * @returns Array of step summaries
+     */
+    async getLastSteps(n, scope, currentSessionId, filters) {
+        const sessionIds = await this.resolveSessionIds(scope, currentSessionId, filters);
+        const allSteps = [];
+        for (const sid of sessionIds) {
+            const steps = await __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_loadSessionSteps).call(this, sid);
+            for (const s of steps) {
+                if (__classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_stepMatchesFilters).call(this, s.step, filters)) {
+                    allSteps.push(s);
+                }
+            }
+        }
+        allSteps.sort((a, b) => new Date(b.step.timestamp).getTime() -
+            new Date(a.step.timestamp).getTime());
+        return allSteps.slice(0, n).map((item) => __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_summarizeStep).call(this, item.step));
+    }
+    /**
+     * Search steps by query across sessions
+     *
+     * @param query - Search query string
+     * @param limit - Maximum number of results to return
+     * @param scope - Scope for search (current, all, or specific sessionId)
+     * @param currentSessionId - Current session ID for scope resolution
+     * @param filters - Optional filters to apply to steps
+     * @returns Array of matching step summaries
+     */
+    async searchSteps(query, limit, scope, currentSessionId, filters) {
+        const queryTokens = tokenize(query);
+        if (queryTokens.length === 0) {
+            return [];
+        }
+        const expandedTokens = expandWithSynonyms(queryTokens);
+        const sessionIds = await this.resolveSessionIds(scope, currentSessionId, filters);
+        const scoredSessions = [];
+        for (const sid of sessionIds) {
+            const metadata = await __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_readSessionMetadata).call(this, sid);
+            const sessionScore = metadata
+                ? __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_computeSessionScore).call(this, metadata, expandedTokens)
+                : 0;
+            scoredSessions.push({
+                sessionId: sid,
+                score: sessionScore,
+                metadata: metadata ?? undefined,
+            });
+        }
+        scoredSessions.sort((a, b) => {
+            if (b.score !== a.score) {
+                return b.score - a.score;
+            }
+            const aTime = a.metadata?.createdAt
+                ? new Date(a.metadata.createdAt).getTime()
+                : 0;
+            const bTime = b.metadata?.createdAt
+                ? new Date(b.metadata.createdAt).getTime()
+                : 0;
+            if (bTime !== aTime) {
+                return bTime - aTime;
+            }
+            return a.sessionId.localeCompare(b.sessionId);
+        });
+        const topSessions = scoredSessions.slice(0, SCAN_LIMITS.maxSessionsToScan);
+        const matches = [];
+        let totalStepsScanned = 0;
+        for (const { sessionId: sid, score: sessionScore, metadata, } of topSessions) {
+            if (totalStepsScanned >= SCAN_LIMITS.maxTotalSteps) {
+                break;
+            }
+            const steps = await __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_loadSessionSteps).call(this, sid);
+            const limitedSteps = steps.slice(0, SCAN_LIMITS.maxStepsPerSession);
+            totalStepsScanned += limitedSteps.length;
+            for (const { step } of limitedSteps) {
+                if (!__classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_stepMatchesFilters).call(this, step, filters)) {
+                    continue;
+                }
+                const { score: stepScore, matchedFields } = __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_computeSearchScore).call(this, step, expandedTokens);
+                const combinedScore = sessionScore + stepScore;
+                if (combinedScore > 0) {
+                    matches.push({
+                        step,
+                        score: combinedScore,
+                        sessionScore,
+                        sessionGoal: metadata?.goal,
+                        matchedFields,
+                    });
+                }
+            }
+        }
+        matches.sort((a, b) => b.score - a.score);
+        return matches
+            .slice(0, limit)
+            .map((m) => __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_summarizeStep).call(this, m.step, m.matchedFields, m.sessionGoal));
+    }
+    /**
+     * Generate a recipe summary of steps in a session
+     *
+     * @param sessionId - Session ID to summarize
+     * @returns Session summary with recipe steps
+     */
+    async summarizeSession(sessionId) {
+        const steps = await __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_loadSessionSteps).call(this, sessionId);
+        steps.sort((a, b) => new Date(a.step.timestamp).getTime() -
+            new Date(b.step.timestamp).getTime());
+        const recipe = steps.map(({ step }, index) => ({
+            stepNumber: index + 1,
+            tool: step.tool.name,
+            notes: __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_generateStepNotes).call(this, step),
+        }));
+        return {
+            sessionId,
+            stepCount: steps.length,
+            recipe,
+        };
+    }
+    /**
+     * Get all session IDs from the knowledge store
+     *
+     * @returns Array of all session IDs
+     */
+    async getAllSessionIds() {
+        try {
+            const entries = await fs.readdir(__classPrivateFieldGet(this, _KnowledgeStore_knowledgeRoot, "f"), {
+                withFileTypes: true,
+            });
+            return entries
+                .filter((e) => e.isDirectory() &&
+                (e.name.startsWith('mm-') ||
+                    e.name.startsWith(__classPrivateFieldGet(this, _KnowledgeStore_sessionIdPrefix, "f"))))
+                .map((e) => e.name);
+        }
+        catch (error) {
+            debugWarn('knowledge-store.getAllSessionIds', error);
+            return [];
+        }
+    }
+    /**
+     * Generate prior knowledge from historical sessions
+     *
+     * @param context - Current context for knowledge generation
+     * @param currentSessionId - Current session ID to exclude from results
+     * @returns Prior knowledge object or undefined if no relevant data found
+     */
+    async generatePriorKnowledge(context, currentSessionId) {
+        const { windowHours } = PRIOR_KNOWLEDGE_CONFIG;
+        const filters = {
+            sinceHours: windowHours,
+        };
+        if (context.currentSessionFlowTags?.length) {
+            filters.flowTag = context.currentSessionFlowTags[0];
+        }
+        const sessionIds = await this.resolveSessionIds('all', undefined, filters);
+        const candidateSessionIds = sessionIds.filter((sid) => sid !== currentSessionId);
+        if (candidateSessionIds.length === 0) {
+            return undefined;
+        }
+        const relatedSessions = await __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_getRelatedSessions).call(this, candidateSessionIds, filters, PRIOR_KNOWLEDGE_CONFIG.maxRelatedSessions);
+        const { similarSteps, candidateStepCount } = await __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_getSimilarSteps).call(this, context, candidateSessionIds, filters);
+        const suggestedNextActions = __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_buildSuggestedActions).call(this, similarSteps, context);
+        const avoidList = await __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_buildAvoidList).call(this, context, candidateSessionIds);
+        if (relatedSessions.length === 0 &&
+            similarSteps.length === 0 &&
+            suggestedNextActions.length === 0) {
+            return undefined;
+        }
+        return {
+            schemaVersion: 1,
+            generatedAt: new Date().toISOString(),
+            query: {
+                windowHours,
+                usedFlowTags: context.currentSessionFlowTags ?? [],
+                usedFilters: filters,
+                candidateSessions: candidateSessionIds.length,
+                candidateSteps: candidateStepCount,
+            },
+            relatedSessions,
+            similarSteps: similarSteps.slice(0, PRIOR_KNOWLEDGE_CONFIG.maxSimilarSteps),
+            suggestedNextActions: suggestedNextActions.slice(0, PRIOR_KNOWLEDGE_CONFIG.maxSuggestedActions),
+            avoid: avoidList.length > 0
+                ? avoidList.slice(0, PRIOR_KNOWLEDGE_CONFIG.maxAvoid)
+                : undefined,
+        };
+    }
+}
+_KnowledgeStore_knowledgeRoot = new WeakMap(), _KnowledgeStore_sessionIdPrefix = new WeakMap(), _KnowledgeStore_toolPrefix = new WeakMap(), _KnowledgeStore_sessionMetadataCache = new WeakMap(), _KnowledgeStore_actionableTools = new WeakMap(), _KnowledgeStore_toolActionMap = new WeakMap(), _KnowledgeStore_discoveryTools = new WeakMap(), _KnowledgeStore_instances = new WeakSet(), _KnowledgeStore_readSessionMetadata = 
+/**
+ * Read session metadata from disk (private)
+ *
+ * @param sessionId - Session ID to read metadata for
+ * @returns Session metadata or null if not found
+ */
+async function _KnowledgeStore_readSessionMetadata(sessionId) {
+    if (__classPrivateFieldGet(this, _KnowledgeStore_sessionMetadataCache, "f").has(sessionId)) {
+        return __classPrivateFieldGet(this, _KnowledgeStore_sessionMetadataCache, "f").get(sessionId) ?? null;
+    }
+    const filepath = path.join(__classPrivateFieldGet(this, _KnowledgeStore_knowledgeRoot, "f"), sessionId, 'session.json');
+    try {
+        const content = await fs.readFile(filepath, 'utf-8');
+        const metadata = JSON.parse(content);
+        __classPrivateFieldGet(this, _KnowledgeStore_sessionMetadataCache, "f").set(sessionId, metadata);
+        return metadata;
+    }
+    catch (error) {
+        debugWarn('knowledge-store.readSessionMetadata', error);
+        __classPrivateFieldGet(this, _KnowledgeStore_sessionMetadataCache, "f").set(sessionId, null);
+        return null;
+    }
+}, _KnowledgeStore_matchesFilters = function _KnowledgeStore_matchesFilters(metadata, filters) {
+    if (!filters) {
+        return true;
+    }
+    if (filters.flowTag && !metadata.flowTags.includes(filters.flowTag)) {
+        return false;
+    }
+    if (filters.tag && !metadata.tags.includes(filters.tag)) {
+        return false;
+    }
+    if (filters.sinceHours) {
+        const cutoff = Date.now() - filters.sinceHours * 60 * 60 * 1000;
+        const createdAt = new Date(metadata.createdAt).getTime();
+        if (createdAt < cutoff) {
+            return false;
+        }
+    }
+    return true;
+}, _KnowledgeStore_computeLabels = function _KnowledgeStore_computeLabels(toolName, target, outcome) {
+    const labels = [];
+    const navigationTools = [
+        `${__classPrivateFieldGet(this, _KnowledgeStore_toolPrefix, "f")}_navigate`,
+        `${__classPrivateFieldGet(this, _KnowledgeStore_toolPrefix, "f")}_wait_for_notification`,
+    ];
+    const interactionTools = [
+        `${__classPrivateFieldGet(this, _KnowledgeStore_toolPrefix, "f")}_click`,
+        `${__classPrivateFieldGet(this, _KnowledgeStore_toolPrefix, "f")}_type`,
+        `${__classPrivateFieldGet(this, _KnowledgeStore_toolPrefix, "f")}_wait_for`,
+    ];
+    if (__classPrivateFieldGet(this, _KnowledgeStore_discoveryTools, "f").includes(toolName)) {
+        labels.push('discovery');
+    }
+    else if (navigationTools.includes(toolName)) {
+        labels.push('navigation');
+    }
+    else if (interactionTools.includes(toolName)) {
+        labels.push('interaction');
+        const targetStr = JSON.stringify(target ?? {}).toLowerCase();
+        if (targetStr.includes('confirm') ||
+            targetStr.includes('approve') ||
+            targetStr.includes('submit')) {
+            labels.push('confirmation');
+        }
+    }
+    if (outcome && !outcome.ok) {
+        labels.push('error-recovery');
+    }
+    return labels;
+}, _KnowledgeStore_stepMatchesFilters = function _KnowledgeStore_stepMatchesFilters(step, filters) {
+    if (!filters) {
+        return true;
+    }
+    if (filters.screen &&
+        step.observation?.state?.currentScreen !== filters.screen) {
+        return false;
+    }
+    return true;
+}, _KnowledgeStore_loadSessionSteps = 
+/**
+ * Load all step records from a session
+ *
+ * @param sessionId - Session ID to load steps from
+ * @returns Array of step records with file paths
+ */
+async function _KnowledgeStore_loadSessionSteps(sessionId) {
+    const stepsDir = path.join(__classPrivateFieldGet(this, _KnowledgeStore_knowledgeRoot, "f"), sessionId, 'steps');
+    try {
+        const files = await fs.readdir(stepsDir);
+        const jsonFiles = files.filter((f) => f.endsWith('.json'));
+        const steps = [];
+        for (const file of jsonFiles) {
+            const filepath = path.join(stepsDir, file);
+            try {
+                const content = await fs.readFile(filepath, 'utf-8');
+                const step = JSON.parse(content);
+                steps.push({ step, filepath });
+            }
+            catch (error) {
+                debugWarn('knowledge-store.loadSessionSteps', error);
+                continue;
+            }
+        }
+        return steps;
+    }
+    catch (error) {
+        debugWarn('knowledge-store.loadSessionSteps', error);
+        return [];
+    }
+}, _KnowledgeStore_sanitizeInput = function _KnowledgeStore_sanitizeInput(toolName, input) {
+    if (!input) {
+        return {};
+    }
+    const sanitized = {};
+    let textRedacted = false;
+    let textLength;
+    const typeToolName = `${__classPrivateFieldGet(this, _KnowledgeStore_toolPrefix, "f")}_type`;
+    for (const [key, value] of Object.entries(input)) {
+        if (toolName === typeToolName && key === 'text') {
+            const textValue = String(value);
+            const targetTestId = input.testId;
+            const targetSelector = input.selector;
+            const isSensitive = isSensitiveField(targetTestId ?? '') ||
+                isSensitiveField(targetSelector ?? '') ||
+                SENSITIVE_FIELD_PATTERNS.some((p) => p.test(key));
+            if (isSensitive) {
+                textRedacted = true;
+                textLength = textValue.length;
+                sanitized[key] = '[REDACTED]';
+            }
+            else {
+                sanitized[key] = value;
+            }
+        }
+        else if (isSensitiveField(key)) {
+            sanitized[key] = '[REDACTED]';
+        }
+        else {
+            sanitized[key] = value;
+        }
+    }
+    return {
+        input: sanitized,
+        textRedacted: textRedacted || undefined,
+        textLength,
+    };
+}, _KnowledgeStore_getEnvironmentInfo = function _KnowledgeStore_getEnvironmentInfo() {
+    return {
+        platform: process.platform,
+        nodeVersion: process.version,
+    };
+}, _KnowledgeStore_summarizeStep = function _KnowledgeStore_summarizeStep(step, matchedFields, sessionGoal) {
+    const screen = step.observation?.state?.currentScreen ?? 'unknown';
+    const snippet = __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_generateSnippet).call(this, step, matchedFields);
+    return {
+        timestamp: step.timestamp,
+        tool: step.tool.name,
+        screen,
+        snippet,
+        sessionId: step.sessionId,
+        matchedFields: matchedFields?.length ? matchedFields : undefined,
+        sessionGoal,
+    };
+}, _KnowledgeStore_generateSnippet = function _KnowledgeStore_generateSnippet(step, matchedFields) {
+    const parts = [];
+    if (matchedFields && matchedFields.length > 0) {
+        const topMatches = matchedFields.slice(0, 3).join(', ');
+        parts.push(`match: ${topMatches}`);
+    }
+    if (step.tool.target?.testId) {
+        parts.push(`testId: ${step.tool.target.testId}`);
+    }
+    else if (step.tool.target?.a11yRef) {
+        parts.push(`ref: ${step.tool.target.a11yRef}`);
+    }
+    else if (step.tool.target?.selector) {
+        const shortSelector = step.tool.target.selector.substring(0, 30);
+        parts.push(`selector: ${shortSelector}`);
+    }
+    if (step.labels && step.labels.length > 0) {
+        parts.push(`labels: ${step.labels.join(', ')}`);
+    }
+    if (step.observation?.state?.currentScreen) {
+        parts.push(`screen: ${step.observation.state.currentScreen}`);
+    }
+    if (!step.outcome.ok && step.outcome.error) {
+        parts.push(`error: ${step.outcome.error.code}`);
+    }
+    return parts.join(', ') || step.tool.name;
+}, _KnowledgeStore_generateStepNotes = function _KnowledgeStore_generateStepNotes(step) {
+    const notes = [];
+    if (step.tool.target?.testId) {
+        notes.push(`target: [data-testid="${step.tool.target.testId}"]`);
+    }
+    else if (step.tool.target?.a11yRef) {
+        notes.push(`target: ${step.tool.target.a11yRef}`);
+    }
+    if (step.observation?.state?.currentScreen) {
+        notes.push(`on screen: ${step.observation.state.currentScreen}`);
+    }
+    if (!step.outcome.ok && step.outcome.error) {
+        notes.push(`FAILED: ${step.outcome.error.message}`);
+    }
+    if (step.artifacts?.screenshot?.path) {
+        notes.push('screenshot captured');
+    }
+    return notes.join('; ') || 'executed';
+}, _KnowledgeStore_computeSessionScore = function _KnowledgeStore_computeSessionScore(metadata, queryTokens) {
+    let score = 0;
+    for (const token of queryTokens) {
+        for (const flowTag of metadata.flowTags) {
+            if (flowTag.toLowerCase().includes(token)) {
+                score += 12;
+                break;
+            }
+        }
+    }
+    const goalTokens = tokenize(metadata.goal ?? '');
+    for (const token of queryTokens) {
+        if (goalTokens.includes(token)) {
+            score += 6;
+        }
+    }
+    for (const token of queryTokens) {
+        for (const tag of metadata.tags) {
+            if (tag.toLowerCase().includes(token)) {
+                score += 4;
+                break;
+            }
+        }
+    }
+    const ageHours = (Date.now() - new Date(metadata.createdAt).getTime()) / (1000 * 60 * 60);
+    if (ageHours < 24) {
+        score += 3;
+    }
+    else if (ageHours < 72) {
+        score += 1;
+    }
+    return score;
+}, _KnowledgeStore_computeSearchScore = function _KnowledgeStore_computeSearchScore(step, queryTokens) {
+    let score = 0;
+    const matchedFieldsSet = new Set();
+    let matchedTokens = 0;
+    const targetTestIdTokens = step.tool.target?.testId
+        ? tokenizeIdentifier(step.tool.target.testId)
+        : [];
+    const observedTestIdTokensMap = new Map();
+    for (const testIdItem of step.observation?.testIds ?? []) {
+        observedTestIdTokensMap.set(testIdItem.testId, tokenizeIdentifier(testIdItem.testId));
+    }
+    for (const token of queryTokens) {
+        let tokenMatched = false;
+        if (step.tool.name.toLowerCase().includes(token)) {
+            score += 10;
+            matchedFieldsSet.add(`tool:${step.tool.name}`);
+            tokenMatched = true;
+        }
+        const screen = step.observation?.state?.currentScreen;
+        if (screen?.toLowerCase().includes(token)) {
+            score += 8;
+            matchedFieldsSet.add(`screen:${screen}`);
+            tokenMatched = true;
+        }
+        if (step.tool.target?.testId && targetTestIdTokens.includes(token)) {
+            score += 6;
+            matchedFieldsSet.add(`testId:${step.tool.target.testId}`);
+            tokenMatched = true;
+        }
+        for (const label of step.labels ?? []) {
+            if (label.toLowerCase().includes(token)) {
+                score += 5;
+                matchedFieldsSet.add(`label:${label}`);
+                tokenMatched = true;
+                break;
+            }
+        }
+        for (const [testId, tokens] of observedTestIdTokensMap) {
+            if (tokens.includes(token)) {
+                score += 3;
+                matchedFieldsSet.add(`testId:${testId}`);
+                tokenMatched = true;
+                break;
+            }
+        }
+        for (const node of step.observation?.a11y?.nodes ?? []) {
+            if (node.name.toLowerCase().includes(token)) {
+                score += 2;
+                matchedFieldsSet.add(`a11y:${node.role}:"${node.name}"`);
+                tokenMatched = true;
+                break;
+            }
+            if (node.role.toLowerCase().includes(token)) {
+                score += 2;
+                matchedFieldsSet.add(`a11y:${node.role}`);
+                tokenMatched = true;
+                break;
+            }
+        }
+        if (tokenMatched) {
+            matchedTokens += 1;
+        }
+    }
+    if (queryTokens.length > 0) {
+        const coverageRatio = matchedTokens / queryTokens.length;
+        score += Math.floor(coverageRatio * 5);
+    }
+    return { score, matchedFields: [...matchedFieldsSet] };
+}, _KnowledgeStore_getRelatedSessions = 
+/**
+ * Get related sessions based on filters
+ *
+ * @param sessionIds - Session IDs to filter
+ * @param filters - Filters to apply
+ * @param limit - Maximum number of sessions to return
+ * @returns Array of related session summaries
+ */
+async function _KnowledgeStore_getRelatedSessions(sessionIds, filters, limit) {
+    const sessions = [];
+    for (const sid of sessionIds) {
+        if (sessions.length >= limit) {
+            break;
+        }
+        const metadata = await __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_readSessionMetadata).call(this, sid);
+        if (!metadata) {
+            continue;
+        }
+        if (!__classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_matchesFilters).call(this, metadata, filters)) {
+            continue;
+        }
+        sessions.push({
+            sessionId: metadata.sessionId,
+            createdAt: metadata.createdAt,
+            goal: metadata.goal,
+            flowTags: metadata.flowTags,
+            tags: metadata.tags,
+        });
+    }
+    return sessions;
+}, _KnowledgeStore_getSimilarSteps = 
+/**
+ * Find similar steps from historical sessions
+ *
+ * @param context - Current context for similarity matching
+ * @param sessionIds - Session IDs to search
+ * @param filters - Filters to apply to steps
+ * @returns Similar steps and total candidate count
+ */
+async function _KnowledgeStore_getSimilarSteps(context, sessionIds, filters) {
+    const scoredSteps = [];
+    let candidateStepCount = 0;
+    const visibleTestIdSet = new Set(context.visibleTestIds.map((t) => t.testId));
+    const visibleA11yNames = new Set(context.a11yNodes.map((n) => n.name.toLowerCase()));
+    const limitedSessionIds = sessionIds.slice(0, SCAN_LIMITS.maxSessionsToScan);
+    for (const sid of limitedSessionIds) {
+        if (candidateStepCount >= SCAN_LIMITS.maxTotalSteps) {
+            break;
+        }
+        const steps = await __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_loadSessionSteps).call(this, sid);
+        const limitedSteps = steps.slice(0, SCAN_LIMITS.maxStepsPerSession);
+        for (const { step } of limitedSteps) {
+            candidateStepCount += 1;
+            if (!__classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_stepMatchesFilters).call(this, step, filters)) {
+                continue;
+            }
+            if (__classPrivateFieldGet(this, _KnowledgeStore_discoveryTools, "f").includes(step.tool.name)) {
+                continue;
+            }
+            const score = __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_computeSimilarityScore).call(this, step, context, visibleTestIdSet, visibleA11yNames);
+            if (score > 0) {
+                scoredSteps.push({ step, score });
+            }
+        }
+    }
+    scoredSteps.sort((a, b) => b.score - a.score);
+    const similarSteps = scoredSteps
+        .slice(0, PRIOR_KNOWLEDGE_CONFIG.maxSimilarSteps)
+        .map(({ step, score }) => {
+        const a11yHint = __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_lookupA11yHint).call(this, step);
+        return {
+            sessionId: step.sessionId,
+            timestamp: step.timestamp,
+            tool: step.tool.name,
+            screen: step.observation?.state?.currentScreen ?? 'unknown',
+            snippet: __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_generateSnippet).call(this, step),
+            labels: step.labels,
+            target: step.tool.target
+                ? {
+                    testId: step.tool.target.testId,
+                    selector: step.tool.target.selector,
+                }
+                : undefined,
+            a11yHint,
+            confidence: Math.min(score / MAX_SIMILARITY_SCORE, 1),
+        };
+    });
+    return { similarSteps, candidateStepCount };
+}, _KnowledgeStore_lookupA11yHint = function _KnowledgeStore_lookupA11yHint(step) {
+    const a11yRef = step.tool.target?.a11yRef;
+    if (!a11yRef) {
+        return undefined;
+    }
+    const nodes = step.observation?.a11y?.nodes ?? [];
+    const matchingNode = nodes.find((node) => node.ref === a11yRef);
+    if (!matchingNode?.name) {
+        return undefined;
+    }
+    return { role: matchingNode.role, name: matchingNode.name };
+}, _KnowledgeStore_computeSimilarityScore = function _KnowledgeStore_computeSimilarityScore(step, context, visibleTestIdSet, visibleA11yNames) {
+    let score = 0;
+    const stepScreen = step.observation?.state?.currentScreen;
+    const contextScreen = context.currentScreen;
+    if (stepScreen === contextScreen && stepScreen !== 'unknown') {
+        score += SIMILARITY_WEIGHTS.sameScreen;
+    }
+    if (context.currentUrl && step.observation?.state) {
+        const currentPathTokens = extractPathTokens(context.currentUrl);
+        const stepUrl = step.observation.state.currentUrl ?? '';
+        const stepPathTokens = extractPathTokens(stepUrl);
+        for (const token of currentPathTokens) {
+            if (stepPathTokens.includes(token)) {
+                score += SIMILARITY_WEIGHTS.urlPathOverlap;
+                break;
+            }
+        }
+    }
+    let testIdOverlapCount = 0;
+    for (const testId of step.observation?.testIds ?? []) {
+        if (visibleTestIdSet.has(testId.testId)) {
+            testIdOverlapCount += 1;
+            if (testIdOverlapCount >= 3) {
+                break;
+            }
+        }
+    }
+    score += Math.min(testIdOverlapCount, 3) * SIMILARITY_WEIGHTS.testIdOverlap;
+    let a11yOverlapCount = 0;
+    for (const node of step.observation?.a11y?.nodes ?? []) {
+        if (visibleA11yNames.has(node.name.toLowerCase())) {
+            a11yOverlapCount += 1;
+            if (a11yOverlapCount >= 2) {
+                break;
+            }
+        }
+    }
+    score += Math.min(a11yOverlapCount, 2) * SIMILARITY_WEIGHTS.a11yOverlap;
+    if (__classPrivateFieldGet(this, _KnowledgeStore_actionableTools, "f").includes(step.tool.name)) {
+        score += SIMILARITY_WEIGHTS.actionableTool;
+    }
+    return score;
+}, _KnowledgeStore_buildSuggestedActions = function _KnowledgeStore_buildSuggestedActions(similarSteps, context) {
+    const visibleTestIdSet = new Set(context.visibleTestIds.map((t) => t.testId));
+    const visibleA11yMap = new Map(context.a11yNodes.map((n) => [n.name.toLowerCase(), n]));
+    const actionCounts = new Map();
+    for (const step of similarSteps) {
+        if (!step.target?.testId && !step.target?.selector) {
+            continue;
+        }
+        const key = step.target.testId ?? step.target.selector ?? '';
+        const existing = actionCounts.get(key);
+        if (existing) {
+            existing.count += 1;
+            existing.confidenceSum += step.confidence;
+        }
+        else {
+            actionCounts.set(key, {
+                step,
+                count: 1,
+                confidenceSum: step.confidence,
+            });
+        }
+    }
+    const suggestions = [];
+    const sortedActions = Array.from(actionCounts.entries()).sort(([, a], [, b]) => b.confidenceSum - a.confidenceSum);
+    for (const [, { step, count, confidenceSum }] of sortedActions) {
+        if (suggestions.length >= PRIOR_KNOWLEDGE_CONFIG.maxSuggestedActions) {
+            break;
+        }
+        const preferredTarget = __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_buildPreferredTarget).call(this, step, visibleTestIdSet);
+        if (!preferredTarget) {
+            continue;
+        }
+        const fallbackTargets = __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_buildFallbackTargets).call(this, preferredTarget, visibleA11yMap);
+        const action = __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_toolToAction).call(this, step.tool);
+        if (!action) {
+            continue;
+        }
+        suggestions.push({
+            rank: suggestions.length + 1,
+            action,
+            rationale: count > 1
+                ? `Used ${count} times successfully on this screen`
+                : 'Most common next successful step on this screen',
+            confidence: Math.min(confidenceSum / count, 1),
+            preferredTarget,
+            fallbackTargets: fallbackTargets.length > 0 ? fallbackTargets : undefined,
+        });
+    }
+    return suggestions;
+}, _KnowledgeStore_buildPreferredTarget = function _KnowledgeStore_buildPreferredTarget(priorStep, visibleTestIdSet) {
+    if (priorStep.target?.testId &&
+        visibleTestIdSet.has(priorStep.target.testId)) {
+        return { type: 'testId', value: priorStep.target.testId };
+    }
+    if (priorStep.target?.selector) {
+        return { type: 'selector', value: priorStep.target.selector };
+    }
+    if (priorStep.a11yHint) {
+        return { type: 'a11yHint', value: priorStep.a11yHint };
+    }
+    return null;
+}, _KnowledgeStore_buildFallbackTargets = function _KnowledgeStore_buildFallbackTargets(preferredTarget, visibleA11yMap) {
+    const fallbacks = [];
+    if (preferredTarget.type === 'testId') {
+        const testId = preferredTarget.value;
+        const entries = Array.from(visibleA11yMap.entries());
+        for (const [name, node] of entries) {
+            if (name.includes(testId.replace(/-/gu, ' ').toLowerCase()) ||
+                testId.toLowerCase().includes(name)) {
+                fallbacks.push({
+                    type: 'a11yHint',
+                    value: { role: node.role, name: node.name },
+                });
+                break;
+            }
+        }
+    }
+    return fallbacks;
+}, _KnowledgeStore_toolToAction = function _KnowledgeStore_toolToAction(toolName) {
+    return __classPrivateFieldGet(this, _KnowledgeStore_toolActionMap, "f")[toolName] ?? null;
+}, _KnowledgeStore_buildAvoidList = 
+/**
+ * Build list of actions to avoid based on failure history
+ *
+ * @param context - Current context for avoid list building
+ * @param sessionIds - Session IDs to analyze for failures
+ * @returns Array of actions to avoid
+ */
+async function _KnowledgeStore_buildAvoidList(context, sessionIds) {
+    const failureCounts = new Map();
+    for (const sid of sessionIds) {
+        const steps = await __classPrivateFieldGet(this, _KnowledgeStore_instances, "m", _KnowledgeStore_loadSessionSteps).call(this, sid);
+        for (const { step } of steps) {
+            if (step.outcome.ok) {
+                continue;
+            }
+            if (step.observation?.state?.currentScreen !== context.currentScreen) {
+                continue;
+            }
+            const targetKey = step.tool.target?.testId ?? step.tool.target?.selector ?? 'unknown';
+            const existing = failureCounts.get(targetKey);
+            if (existing) {
+                existing.count += 1;
+            }
+            else {
+                failureCounts.set(targetKey, {
+                    errorCode: step.outcome.error?.code,
+                    testId: step.tool.target?.testId,
+                    selector: step.tool.target?.selector,
+                    count: 1,
+                });
+            }
+        }
+    }
+    const avoidList = [];
+    const failureEntries = Array.from(failureCounts.values());
+    for (const failure of failureEntries) {
+        if (failure.count < PRIOR_KNOWLEDGE_CONFIG.minAvoidFailureCount) {
+            continue;
+        }
+        avoidList.push({
+            rationale: 'Frequently fails due to UI churn',
+            target: {
+                testId: failure.testId,
+                selector: failure.selector,
+            },
+            errorCode: failure.errorCode,
+            frequency: failure.count,
+        });
+    }
+    avoidList.sort((a, b) => b.frequency - a.frequency);
+    return avoidList;
+};
+/**
+ * Create a default observation object with state and optional artifacts
+ *
+ * @param state - Extension state snapshot
+ * @param testIds - Array of visible test IDs
+ * @param a11yNodes - Array of accessibility nodes
+ * @param priorKnowledge - Optional prior knowledge from history
+ * @returns Observation object for step recording
+ */
+export function createDefaultObservation(state, testIds = [], a11yNodes = [], priorKnowledge) {
+    const observation = {
+        state,
+        testIds,
+        a11y: { nodes: a11yNodes },
+    };
+    if (priorKnowledge) {
+        observation.priorKnowledge = priorKnowledge;
+    }
+    return observation;
+}
+/**
+ * Create a new KnowledgeStore instance
+ *
+ * @param config - Optional configuration for the store
+ * @returns New KnowledgeStore instance
+ */
+export function createKnowledgeStore(config) {
+    return new KnowledgeStore(config);
+}
+let _knowledgeStore;
+/**
+ * Set the global knowledge store instance
+ *
+ * @param store - KnowledgeStore instance to set as global
+ */
+export function setKnowledgeStore(store) {
+    _knowledgeStore = store;
+}
+/**
+ * Get the global knowledge store instance
+ *
+ * @returns The global KnowledgeStore instance
+ */
+export function getKnowledgeStore() {
+    if (!_knowledgeStore) {
+        throw new Error('Knowledge store not initialized. Call setKnowledgeStore() first.');
+    }
+    return _knowledgeStore;
+}
+/**
+ * Check if a knowledge store has been initialized
+ *
+ * @returns True if knowledge store is initialized
+ */
+export function hasKnowledgeStore() {
+    return _knowledgeStore !== undefined;
+}
+export const knowledgeStore = {
+    /**
+     * Record a tool execution step
+     *
+     * @param params - Step recording parameters
+     * @returns Path to the recorded step file
+     */
+    recordStep: async (params) => {
+        return getKnowledgeStore().recordStep(params);
+    },
+    /**
+     * Get the last N steps from the knowledge store
+     *
+     * @param args - Arguments for getLastSteps
+     * @returns Array of step summaries
+     */
+    getLastSteps: async (...args) => {
+        return getKnowledgeStore().getLastSteps(...args);
+    },
+    /**
+     * Search steps by query
+     *
+     * @param args - Arguments for searchSteps
+     * @returns Array of matching step summaries
+     */
+    searchSteps: async (...args) => {
+        return getKnowledgeStore().searchSteps(...args);
+    },
+    /**
+     * Generate a recipe summary of a session
+     *
+     * @param args - Arguments for summarizeSession
+     * @returns Session summary with recipe steps
+     */
+    summarizeSession: async (...args) => {
+        return getKnowledgeStore().summarizeSession(...args);
+    },
+    /**
+     * List sessions with optional filtering
+     *
+     * @param args - Arguments for listSessions
+     * @returns Array of session summaries
+     */
+    listSessions: async (...args) => {
+        return getKnowledgeStore().listSessions(...args);
+    },
+    /**
+     * Generate prior knowledge from historical sessions
+     *
+     * @param args - Arguments for generatePriorKnowledge
+     * @returns Prior knowledge object or undefined
+     */
+    generatePriorKnowledge: async (...args) => {
+        return getKnowledgeStore().generatePriorKnowledge(...args);
+    },
+    /**
+     * Write session metadata to disk
+     *
+     * @param metadata - Session metadata to persist
+     * @returns Path to the written metadata file
+     */
+    writeSessionMetadata: async (metadata) => {
+        return getKnowledgeStore().writeSessionMetadata(metadata);
+    },
+};
+//# sourceMappingURL=knowledge-store.mjs.map