@weavetab/mcp 2.5.0-beta.0

package/dist/intelligence/hints.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Read a domain-specific knowledge hint.
+ * Returns the first non-empty line from the file, trimmed to 20 tokens (≈120 chars).
+ * Returns undefined if no file exists for this domain.
+ */
+export declare function readKnowledgeHint(hostname: string): Promise<string | undefined>;
+/**
+ * Append a discovery note to the domain knowledge file.
+ * Called automatically by healing.ts after recovering a lost element (Rule 16).
+ */
+export declare function appendKnowledgeHint(hostname: string, note: string): Promise<void>;

package/dist/intelligence/hints.js

@@ -0,0 +1,39 @@
+// src/intelligence/hints.ts
+// JIT knowledge hints (Rule 16).
+// Reads ~/.weavetab/knowledge/[domain].md and returns max-20-token hint.
+// Call appendKnowledgeHint() from any tool when you discover a site-specific quirk.
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { GLOBAL_CONFIG_DIR } from "../config/loader.js";
+const KNOWLEDGE_DIR = join(GLOBAL_CONFIG_DIR, "knowledge");
+/**
+ * Read a domain-specific knowledge hint.
+ * Returns the first non-empty line from the file, trimmed to 20 tokens (≈120 chars).
+ * Returns undefined if no file exists for this domain.
+ */
+export async function readKnowledgeHint(hostname) {
+    const safe = hostname.replace(/[^a-zA-Z0-9.-]/g, "_");
+    const filePath = join(KNOWLEDGE_DIR, `${safe}.md`);
+    try {
+        const content = await readFile(filePath, "utf-8");
+        const firstLine = content.split("\n").find((l) => l.trim().length > 0);
+        if (!firstLine)
+            return undefined;
+        // Trim to ~120 chars (~20 tokens)
+        return firstLine.trim().slice(0, 120);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Append a discovery note to the domain knowledge file.
+ * Called automatically by healing.ts after recovering a lost element (Rule 16).
+ */
+export async function appendKnowledgeHint(hostname, note) {
+    const { appendFile } = await import("fs/promises");
+    const safe = hostname.replace(/[^a-zA-Z0-9.-]/g, "_");
+    const filePath = join(KNOWLEDGE_DIR, `${safe}.md`);
+    const timestamp = new Date().toISOString().slice(0, 10);
+    await appendFile(filePath, `\n[${timestamp}] ${note.trim()}\n`, "utf-8");
+}

package/dist/intelligence/intent.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Intent resolution system for interaction tools
+ * Classifies targets and determines optimal interaction strategies before dispatch
+ */
+import CDP from "chrome-remote-interface";
+export interface TargetClassification {
+    /** Element type (button, input, link, etc.) */
+    type: string;
+    /** What interaction is semantically expected */
+    interactionExpected: 'click' | 'type' | 'select' | 'check' | 'upload' | 'scroll';
+    /** Likely success condition */
+    successCondition: string;
+    /** Fallback strategies if primary fails */
+    fallbackStrategies: string[];
+    /** Whether this is a React/Vue controlled component */
+    isControlled: boolean;
+    /** Estimated complexity (simple/complex) */
+    complexity: 'simple' | 'complex';
+}
+/**
+ * Classify a target element to determine optimal interaction strategy
+ * Cheap (1 CDP call) classification that caches results per element
+ */
+export declare function classifyTarget(session: CDP.Client, selector: string): Promise<TargetClassification>;
+/**
+ * Clear classification cache for a specific target or all targets
+ */
+export declare function clearClassificationCache(selector?: string): void;
+/**
+ * Get optimal strategy based on classification
+ * Returns the best strategy to try first
+ */
+export declare function getOptimalStrategy(classification: TargetClassification): string;

package/dist/intelligence/intent.js

@@ -0,0 +1,171 @@
+/**
+ * Intent resolution system for interaction tools
+ * Classifies targets and determines optimal interaction strategies before dispatch
+ */
+// Simple in-memory cache for classification results
+const classificationCache = new Map();
+const CACHE_TTL_MS = 30000; // 30 seconds
+const CACHE_MAX_SIZE = 500; // hard cap to prevent unbounded growth
+// Stale entries are checked on read, but a background sweep removes expired
+// entries every 60 s and a max-size cap (evict oldest first) keeps the cache
+// from growing without bound even for keys that are never looked up again.
+setInterval(() => {
+    const now = Date.now();
+    for (const [k, v] of classificationCache.entries()) {
+        if (now - v.timestamp >= CACHE_TTL_MS)
+            classificationCache.delete(k);
+    }
+}, 60_000).unref(); // .unref() so this interval never prevents process exit
+/**
+ * Classify a target element to determine optimal interaction strategy
+ * Cheap (1 CDP call) classification that caches results per element
+ */
+export async function classifyTarget(session, selector) {
+    // Check cache first
+    const cacheKey = (session.target?.targetId || 'default') + ":" + selector;
+    const cached = classificationCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+        return cached.classification;
+    }
+    // Enforce max-size cap before inserting a new entry (evict oldest)
+    if (classificationCache.size >= CACHE_MAX_SIZE) {
+        const firstKey = classificationCache.keys().next().value;
+        if (firstKey !== undefined)
+            classificationCache.delete(firstKey);
+    }
+    try {
+        const { result } = await session.Runtime.evaluate({
+            expression: `(function(sel) {
+        try {
+          var el = document.querySelector(sel);
+          if (!el) return JSON.stringify({ error: 'not_found' });
+          
+          var tag = el.tagName.toLowerCase();
+          var typeAttr = (el.getAttribute('type') || 'text').toLowerCase();
+          var role = el.getAttribute('role') || '';
+          var isControlled = false;
+          
+          // Detect React/Vue controlled components
+          if ((el as any)._reactInternalFiber || (el as any)._reactRootContainer || 
+              (el as any).__vueApp__ || (el as any).__VUE__ || 
+              el.hasAttribute('data-reactroot')) {
+            isControlled = true;
+          }
+          
+          var classification: any = {
+            type: tag,
+            interactionExpected: 'click',
+            successCondition: 'element_clicked',
+            fallbackStrategies: [],
+            isControlled: isControlled,
+            complexity: 'simple'
+          };
+          
+          // Determine interaction type based on element
+          if (tag === 'input') {
+            if (typeAttr === 'checkbox' || typeAttr === 'radio') {
+              classification.interactionExpected = 'check';
+              classification.successCondition = 'checked_state_changed';
+              classification.fallbackStrategies = ['click', 'property_set'];
+            } else if (typeAttr === 'file') {
+              classification.interactionExpected = 'upload';
+              classification.successCondition = 'file_selected';
+              classification.fallbackStrategies = ['click', 'direct_upload'];
+            } else if (typeAttr === 'submit' || typeAttr === 'button') {
+              classification.interactionExpected = 'click';
+              classification.successCondition = 'form_submitted_or_clicked';
+              classification.fallbackStrategies = ['click', 'form_submit'];
+            } else {
+              classification.interactionExpected = 'type';
+              classification.successCondition = 'value_changed';
+              classification.fallbackStrategies = ['native_setter', 'react_setter', 'dispatch_events'];
+              classification.complexity = isControlled ? 'complex' : 'simple';
+            }
+          } else if (tag === 'textarea') {
+            classification.interactionExpected = 'type';
+            classification.successCondition = 'value_changed';
+            classification.fallbackStrategies = ['native_setter', 'react_setter', 'dispatch_events'];
+            classification.complexity = isControlled ? 'complex' : 'simple';
+          } else if (tag === 'select') {
+            classification.interactionExpected = 'select';
+            classification.successCondition = 'selection_changed';
+            classification.fallbackStrategies = ['property_set', 'click_option'];
+            classification.complexity = isControlled ? 'complex' : 'simple';
+          } else if (tag === 'button' || role === 'button') {
+            classification.interactionExpected = 'click';
+            classification.successCondition = 'clicked';
+            classification.fallbackStrategies = ['click', 'keyboard_enter'];
+          } else if (tag === 'a') {
+            classification.interactionExpected = 'click';
+            classification.successCondition = 'navigated';
+            classification.fallbackStrategies = ['click', 'direct_navigate'];
+          } else if (tag === 'div' || tag === 'span') {
+            if (role === 'textbox' || role === 'combobox' || (el as any).isContentEditable) {
+              classification.interactionExpected = 'type';
+              classification.successCondition = 'text_changed';
+              classification.fallbackStrategies = ['text_content_set', 'dispatch_events'];
+              classification.complexity = 'complex';
+            } else {
+              classification.interactionExpected = 'click';
+              classification.successCondition = 'clicked';
+              classification.fallbackStrategies = ['click'];
+            }
+          }
+          
+          return JSON.stringify(classification);
+        } catch(e) {
+          return JSON.stringify({ error: (e as Error).message });
+        }
+      })(${JSON.stringify(selector)})`,
+            returnByValue: true,
+        });
+        const classification = result?.value;
+        // Cache the result
+        if (classification && !classification.error) {
+            classificationCache.set(cacheKey, { classification, timestamp: Date.now() });
+        }
+        return classification;
+    }
+    catch (error) {
+        // Return safe default on error
+        return {
+            type: 'unknown',
+            interactionExpected: 'click',
+            successCondition: 'clicked',
+            fallbackStrategies: ['click'],
+            isControlled: false,
+            complexity: 'simple'
+        };
+    }
+}
+/**
+ * Clear classification cache for a specific target or all targets
+ */
+export function clearClassificationCache(selector) {
+    if (selector) {
+        // Clear specific selector entries
+        for (const [key] of classificationCache) {
+            if (key.endsWith(":" + selector)) {
+                classificationCache.delete(key);
+            }
+        }
+    }
+    else {
+        // Clear all cache
+        classificationCache.clear();
+    }
+}
+/**
+ * Get optimal strategy based on classification
+ * Returns the best strategy to try first
+ */
+export function getOptimalStrategy(classification) {
+    // For controlled components, prefer React-specific strategies
+    if (classification.isControlled) {
+        if (classification.interactionExpected === 'type') {
+            return 'react_setter';
+        }
+    }
+    // Default to first fallback strategy
+    return classification.fallbackStrategies[0] || classification.interactionExpected;
+}

package/dist/intelligence/sessionMemory.d.ts

@@ -0,0 +1,66 @@
+import CDP from "chrome-remote-interface";
+export type FailureType = "DEAD_SELECTOR" | "ACTION_FAILED";
+export interface SelectorFingerprint {
+    tag?: string;
+    classes?: string[];
+    role?: string;
+    relativeTo?: string;
+    structuralIdiom?: string;
+}
+export interface MemoryEntry {
+    intent: string;
+    selector: string;
+    urlPath?: string;
+    fingerprint?: SelectorFingerprint;
+    successCount: number;
+    failureCount: number;
+    consecutiveFailures: number;
+    lastSuccessVisit: number;
+    state: "active" | "drift_detected" | "deprecated";
+}
+export interface NegativeMemoryEntry {
+    selector: string;
+    urlPath?: string;
+    failureType: FailureType;
+    expiredAtVisit: number;
+}
+export interface DomainProfile {
+    domainFamily?: string;
+    strategies: string[];
+    memories: MemoryEntry[];
+    failedSelectors: NegativeMemoryEntry[];
+    shadowDom: boolean;
+    framework?: string;
+    updatedAt: string;
+    visitCount: number;
+}
+export declare function loadDomainProfile(hostname: string): Promise<DomainProfile | null>;
+export declare function saveDomainProfile(hostname: string, updates: Partial<DomainProfile>): Promise<DomainProfile>;
+/**
+ * Increment the visit counter for a domain. Call this exactly once per page navigation,
+ * NOT on every logMemorySuccess/Failure call.
+ */
+export declare function bumpVisitCount(hostname: string): Promise<void>;
+export declare function logMemorySuccess(hostname: string, intent: string, selector: string, fingerprint?: SelectorFingerprint, urlPath?: string): Promise<void>;
+export declare function logMemoryFailure(hostname: string, intent: string, selector: string, failureType: FailureType, urlPath?: string): Promise<void>;
+export interface MemoryHit {
+    selector: string;
+    fingerprint?: SelectorFingerprint;
+    score: number;
+}
+/**
+ * Evaluates memory entries and returns the highest confidence memory hit.
+ */
+export declare function getBestSelectorForIntent(hostname: string, intent: string, urlPath?: string): Promise<MemoryHit | undefined>;
+/**
+ * Detect the frontend framework used by the current page.
+ */
+export declare function detectFramework(session: CDP.Client): Promise<string | undefined>;
+/**
+ * Check if the page uses Shadow DOM.
+ */
+export declare function detectShadowDom(session: CDP.Client): Promise<boolean>;
+/**
+ * Format a domain profile as a system hint string.
+ */
+export declare function formatDomainHint(hostname: string, profile: DomainProfile): string | undefined;

package/dist/intelligence/sessionMemory.js

@@ -0,0 +1,284 @@
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { GLOBAL_CONFIG_DIR } from "../config/loader.js";
+import { logDebug } from "../audit/logger.js";
+import fs from "fs";
+function domainFile(hostname) {
+    const safe = hostname.replace(/[^a-zA-Z0-9.-]/g, "_");
+    const memoryDir = join(GLOBAL_CONFIG_DIR, "memory");
+    if (!fs.existsSync(memoryDir))
+        fs.mkdirSync(memoryDir, { recursive: true });
+    return join(memoryDir, `${safe}.json`);
+}
+// memoryCache is capped at 200 DomainProfile entries (one per unique hostname).
+// When the cap is hit, the oldest entry is evicted (insertion-order LRU) so the
+// cache can't grow without bound over a long session.
+const memoryCache = new Map();
+const MEMORY_CACHE_MAX = 200;
+function memoryCacheSet(hostname, profile) {
+    if (memoryCache.size >= MEMORY_CACHE_MAX && !memoryCache.has(hostname)) {
+        // Evict the oldest (first) entry
+        const firstKey = memoryCache.keys().next().value;
+        if (firstKey !== undefined)
+            memoryCache.delete(firstKey);
+    }
+    memoryCache.set(hostname, profile);
+}
+export async function loadDomainProfile(hostname) {
+    if (memoryCache.has(hostname)) {
+        return memoryCache.get(hostname);
+    }
+    try {
+        const content = await readFile(domainFile(hostname), "utf-8");
+        const profile = JSON.parse(content);
+        // Auto-expire negative memory
+        profile.failedSelectors = profile.failedSelectors.filter((neg) => profile.visitCount < neg.expiredAtVisit);
+        // Decay and drift detection
+        for (const mem of profile.memories) {
+            const visitsSinceSuccess = profile.visitCount - mem.lastSuccessVisit;
+            if (mem.consecutiveFailures >= 3 && mem.successCount > 5) {
+                mem.state = "drift_detected";
+            }
+            else if (visitsSinceSuccess > 20) {
+                // Simple heuristic: if we visited the domain 20 times and didn't use this successfully, decay
+                // For now just keep it active, confidence scoring will handle the numeric decay
+                if (mem.state !== "deprecated") {
+                    mem.state = "active";
+                }
+            }
+        }
+        memoryCacheSet(hostname, profile);
+        return profile;
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveDomainProfile(hostname, updates) {
+    const existing = await loadDomainProfile(hostname);
+    // NOTE: visitCount is NOT bumped here — call bumpVisitCount() only on page navigation.
+    const visitCount = existing?.visitCount ?? 0;
+    const profile = {
+        strategies: [],
+        memories: [],
+        failedSelectors: [],
+        shadowDom: false,
+        ...existing,
+        ...updates,
+        updatedAt: new Date().toISOString(),
+        visitCount,
+    };
+    // Dedup strategies
+    if (updates.strategies) {
+        profile.strategies = Array.from(new Set([...(existing?.strategies || []), ...updates.strategies]));
+    }
+    memoryCacheSet(hostname, profile);
+    // Gate profile writing on 3+ data points
+    let dataPoints = profile.failedSelectors.length;
+    for (const mem of profile.memories) {
+        dataPoints += (mem.successCount + mem.failureCount);
+    }
+    if (dataPoints >= 3) {
+        await writeFile(domainFile(hostname), JSON.stringify(profile, null, 2), "utf-8");
+    }
+    return profile;
+}
+/**
+ * Increment the visit counter for a domain. Call this exactly once per page navigation,
+ * NOT on every logMemorySuccess/Failure call.
+ */
+export async function bumpVisitCount(hostname) {
+    const existing = await loadDomainProfile(hostname);
+    const visitCount = (existing?.visitCount ?? 0) + 1;
+    await saveDomainProfile(hostname, { visitCount });
+}
+export async function logMemorySuccess(hostname, intent, selector, fingerprint, urlPath) {
+    const profile = (await loadDomainProfile(hostname)) || {
+        strategies: [],
+        memories: [],
+        failedSelectors: [],
+        shadowDom: false,
+        updatedAt: new Date().toISOString(),
+        visitCount: 0,
+    };
+    let mem = profile.memories.find(m => m.intent === intent && m.selector === selector);
+    if (!mem) {
+        mem = {
+            intent,
+            selector,
+            urlPath,
+            fingerprint,
+            successCount: 0,
+            failureCount: 0,
+            consecutiveFailures: 0,
+            lastSuccessVisit: profile.visitCount,
+            state: "active"
+        };
+        profile.memories.push(mem);
+    }
+    mem.successCount++;
+    mem.consecutiveFailures = 0;
+    mem.lastSuccessVisit = profile.visitCount;
+    if (fingerprint) {
+        mem.fingerprint = { ...mem.fingerprint, ...fingerprint };
+    }
+    mem.state = "active";
+    logDebug(`[Memory] Success logged for selector '${selector}' on intent '${intent}'.`);
+    // If it was in failedSelectors, remove it
+    profile.failedSelectors = profile.failedSelectors.filter(f => f.selector !== selector);
+    await saveDomainProfile(hostname, {
+        memories: profile.memories,
+        failedSelectors: profile.failedSelectors
+    });
+}
+export async function logMemoryFailure(hostname, intent, selector, failureType, urlPath) {
+    const profile = (await loadDomainProfile(hostname)) || {
+        strategies: [],
+        memories: [],
+        failedSelectors: [],
+        shadowDom: false,
+        updatedAt: new Date().toISOString(),
+        visitCount: 0,
+    };
+    const mem = profile.memories.find(m => m.intent === intent && m.selector === selector);
+    if (mem) {
+        mem.failureCount++;
+        mem.consecutiveFailures++;
+        logDebug(`[Memory] Failure logged for selector '${selector}'. Consecutive failures: ${mem.consecutiveFailures}`);
+        if (mem.consecutiveFailures >= 5) {
+            logDebug(`[Memory] Selector '${selector}' deprecated due to 5 consecutive failures.`);
+            mem.state = "deprecated";
+        }
+    }
+    // Add to negative memory, expires after 50 visits
+    const existingNeg = profile.failedSelectors.find(f => f.selector === selector);
+    if (existingNeg) {
+        existingNeg.expiredAtVisit = profile.visitCount + 50;
+        existingNeg.failureType = failureType;
+    }
+    else {
+        profile.failedSelectors.push({
+            selector,
+            urlPath,
+            failureType,
+            expiredAtVisit: profile.visitCount + 50
+        });
+    }
+    await saveDomainProfile(hostname, {
+        memories: profile.memories,
+        failedSelectors: profile.failedSelectors
+    });
+}
+/**
+ * Evaluates memory entries and returns the highest confidence memory hit.
+ */
+export async function getBestSelectorForIntent(hostname, intent, urlPath) {
+    const profile = await loadDomainProfile(hostname);
+    if (!profile)
+        return undefined;
+    let validMemories = profile.memories.filter(m => m.intent === intent && m.state !== "deprecated");
+    if (urlPath && validMemories.some(m => m.urlPath === urlPath)) {
+        // Exact path match takes precedence
+        validMemories = validMemories.filter(m => m.urlPath === urlPath);
+    }
+    else if (urlPath) {
+        // If no exact match, try broad match (e.g. same base path) or fallback to global
+        const base = urlPath.split('/')[1];
+        const baseMatches = validMemories.filter(m => m.urlPath && m.urlPath.startsWith(`/${base}`));
+        if (baseMatches.length > 0) {
+            validMemories = baseMatches;
+        }
+    }
+    if (validMemories.length === 0)
+        return undefined;
+    // Score = successRate * decayFactor - penalty
+    const scored = validMemories.map(mem => {
+        const totalAttempts = mem.successCount + mem.failureCount;
+        const confidence = totalAttempts > 0 ? mem.successCount / totalAttempts : 0;
+        const visitsSinceSuccess = Math.max(0, profile.visitCount - mem.lastSuccessVisit);
+        // Decay factor (staleness): drops 5% per visit without success, floor at 0.1
+        const decayFactor = Math.max(0.1, 1 - (visitsSinceSuccess * 0.05));
+        // Penalty for recent consecutive failures (reliability cliff)
+        const penalty = mem.consecutiveFailures * 0.2;
+        const finalScore = (confidence * decayFactor) - penalty;
+        logDebug(`[Memory] Evaluated intent '${intent}' on selector '${mem.selector}': Confidence=${confidence.toFixed(2)}, DecayFactor=${decayFactor.toFixed(2)}, Penalty=${penalty.toFixed(2)} => FinalScore=${finalScore.toFixed(2)}`);
+        return { ...mem, score: finalScore };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    const best = scored[0];
+    if (best.score > 0.5) {
+        logDebug(`[Memory] Hit! Skipping LLM. High-confidence selector for '${intent}': ${best.selector} (Score: ${best.score.toFixed(2)})`);
+        return { selector: best.selector, fingerprint: best.fingerprint, score: best.score };
+    }
+    logDebug(`[Memory] Miss. No selector met the 0.5 score threshold for intent '${intent}'. Falling back to DOM heuristic / LLM.`);
+    return undefined;
+}
+/**
+ * Detect the frontend framework used by the current page.
+ */
+export async function detectFramework(session) {
+    const checks = [
+        { expr: `!!window.__REACT_DEVTOOLS_GLOBAL_HOOK__ && !!document.querySelector('[data-reactroot], [data-reactid]')`, name: 'react' },
+        { expr: `!!window.__VUE__ || !!document.querySelector('[data-v-]')`, name: 'vue' },
+        { expr: `!!window.angular || !!document.querySelector('[ng-]')`, name: 'angular' },
+        { expr: `!!window.LitElement || !!document.querySelector('[lit-element]')`, name: 'lit' },
+        { expr: `!!window.SvelteComponent || !!document.querySelector('[svelte]')`, name: 'svelte' },
+        { expr: `!!window.NextRouter`, name: 'next' },
+        { expr: `!!window.__NUXT__`, name: 'nuxt' },
+        { expr: `!!window.Gatsby`, name: 'gatsby' },
+    ];
+    for (const check of checks) {
+        try {
+            const resp = await session.Runtime.evaluate({
+                expression: `(function() { return ${check.expr}; })()`,
+                returnByValue: true,
+            });
+            if (resp?.result?.value)
+                return check.name;
+        }
+        catch { /* ignore */ }
+    }
+    return undefined;
+}
+/**
+ * Check if the page uses Shadow DOM.
+ */
+export async function detectShadowDom(session) {
+    try {
+        const resp = await session.Runtime.evaluate({
+            expression: `(function() {
+        return document.querySelectorAll('*').some(el => el.shadowRoot !== null);
+      })()`,
+            returnByValue: true,
+        });
+        return !!resp?.result?.value;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Format a domain profile as a system hint string.
+ */
+export function formatDomainHint(hostname, profile) {
+    const parts = [];
+    if (profile.framework)
+        parts.push(`framework: ${profile.framework}`);
+    if (profile.shadowDom)
+        parts.push('uses Shadow DOM');
+    if (profile.strategies.length > 0)
+        parts.push(`known strategies: ${profile.strategies.join(', ')}`);
+    const activeMemories = profile.memories.filter(m => m.state !== "deprecated");
+    if (activeMemories.length > 0) {
+        const inputs = activeMemories.map(k => {
+            let flag = '';
+            if (k.state === 'drift_detected')
+                flag = ' [DRIFT_DETECTED: site may have changed]';
+            return `${k.intent} (${k.selector})${flag}`;
+        }).join('; ');
+        parts.push(`known intents: ${inputs}`);
+    }
+    if (parts.length === 0)
+        return undefined;
+    return `[Session Memory] ${hostname}: ${parts.join(' | ')}`;
+}

package/dist/intelligence/sessionMemory.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sessionMemory.test.d.ts.map

package/dist/intelligence/sessionMemory.test.js

@@ -0,0 +1,62 @@
+/**
+ * sessionMemory.test.ts — Phase 1.1
+ * Integrated into node:test runner (npm test / npm run test:unit).
+ * Previously a manual runTests() script; ported to node:test format.
+ */
+import { test, before, after } from "node:test";
+import assert from "node:assert/strict";
+import fs from "fs";
+import path from "path";
+import { getBestSelectorForIntent, logMemorySuccess, logMemoryFailure, loadDomainProfile, } from "./sessionMemory.js";
+import { getSystemDir } from "../config/loader.js";
+const hostname = "test.weavetab.dev";
+let profilePath;
+before(() => {
+    const memoryDir = getSystemDir("memory");
+    profilePath = path.join(memoryDir, `${hostname}.json`);
+    if (fs.existsSync(profilePath))
+        fs.unlinkSync(profilePath);
+});
+after(() => {
+    if (fs.existsSync(profilePath))
+        fs.unlinkSync(profilePath);
+});
+test("1: Initial success log — selector is immediately retrievable", async () => {
+    await logMemorySuccess(hostname, "Click Login", ".login-btn", { role: "button", tag: "button" });
+    const sel = await getBestSelectorForIntent(hostname, "Click Login");
+    assert.equal(sel?.selector, ".login-btn", `Expected .login-btn, got ${sel?.selector}`);
+});
+test("2: Dead selector (first strike) — score drops below threshold", async () => {
+    // Simulate visit count increment
+    const profile = await loadDomainProfile(hostname);
+    profile.visitCount++;
+    fs.writeFileSync(profilePath, JSON.stringify(profile, null, 2));
+    await logMemoryFailure(hostname, "Click Login", ".login-btn", "DEAD_SELECTOR");
+    const sel = await getBestSelectorForIntent(hostname, "Click Login");
+    assert.equal(sel, undefined, "Expected undefined — score dropped below 0.5 threshold after one failure");
+});
+test("3: Dead selector recovery — new successful selector wins", async () => {
+    await logMemorySuccess(hostname, "Click Login", "#login-new", { role: "button", tag: "button" });
+    const sel = await getBestSelectorForIntent(hostname, "Click Login");
+    assert.equal(sel?.selector, "#login-new", `Expected #login-new, got ${sel?.selector}`);
+});
+test("4: Decay check — both old and new memory entries exist in profile", async () => {
+    const profile = await loadDomainProfile(hostname);
+    const oldMem = profile.memories.find(m => m.selector === ".login-btn");
+    const newMem = profile.memories.find(m => m.selector === "#login-new");
+    assert.ok(oldMem !== undefined, "Expected old memory (.login-btn) to still exist");
+    assert.ok(newMem !== undefined, "Expected new memory (#login-new) to exist");
+});
+test("5: Negative memory expiration — both selectors decay below threshold after many visits", async () => {
+    const profile = await loadDomainProfile(hostname);
+    const inFailed = profile.failedSelectors.find(f => f.selector === ".login-btn");
+    assert.ok(inFailed !== undefined, "Expected .login-btn in failedSelectors after DEAD_SELECTOR strike");
+    // Advance visits far past expiration window (expiration = visitCount + 10).
+    // After +15 visits, DecayFactor drops to ~0.25, pulling #login-new below 0.5 threshold too.
+    profile.visitCount += 15;
+    fs.writeFileSync(profilePath, JSON.stringify(profile, null, 2));
+    // Both selectors are now expired / decayed — correct behavior is a miss (force DOM re-resolution)
+    const sel = await getBestSelectorForIntent(hostname, "Click Login");
+    assert.equal(sel, undefined, "Expected undefined after extreme visit-count decay — selectors should re-confirm via DOM");
+});
+//# sourceMappingURL=sessionMemory.test.js.map