@tpsdev-ai/flair 0.2.0 → 0.3.0

package/dist/resources/MemoryBootstrap.js

@@ -54,12 +54,22 @@ export class BootstrapMemories extends Resource {
         let tokenBudget = maxTokens;
         let memoriesIncluded = 0;
         let memoriesAvailable = 0;
-        // --- 1. Soul records (unconditional — not subject to token budget) ---
-        // Soul is who you are. It's not optional context to be trimmed.
-        // Skill assignments (key='skill-assignment') are separated into their own section.
+        // --- 1. Soul records (budgeted — prioritized by key importance) ---
+        // Soul is who you are, but we still need to respect token budgets.
+        // Workspace files (SOUL.md, AGENTS.md) can be massive — they're already
+        // injected by the runtime via workspace context, so we prioritize
+        // concise soul entries over full file dumps.
+        const SOUL_KEY_PRIORITY = {
+            role: 0, identity: 1, thinking: 2, communication_style: 3,
+            team: 4, ownership: 5, infrastructure: 6, "user-context": 7,
+            // Full workspace files — lowest priority (runtime already injects these)
+            soul: 90, "workspace-rules": 91,
+        };
         const skillAssignments = [];
+        const soulMaxTokens = Math.floor(maxTokens * 0.4); // 40% of budget for soul
         if (includeSoul) {
             let soulTokens = 0;
+            const soulEntries = [];
             for await (const record of databases.flair.Soul.search()) {
                 if (record.agentId !== agentId)
                     continue;
@@ -68,11 +78,29 @@ export class BootstrapMemories extends Resource {
                     continue;
                 }
                 const line = `**${record.key}:** ${record.value}`;
-                sections.soul.push(line);
-                soulTokens += estimateTokens(line);
+                const tokens = estimateTokens(line);
+                const priority = SOUL_KEY_PRIORITY[record.key] ?? 50;
+                soulEntries.push({ key: record.key, line, tokens, priority });
+            }
+            // Sort by priority (lower = more important)
+            soulEntries.sort((a, b) => a.priority - b.priority);
+            for (const entry of soulEntries) {
+                if (soulTokens + entry.tokens > soulMaxTokens) {
+                    // Skip large entries that exceed budget — truncate or skip
+                    if (entry.priority >= 90)
+                        continue; // skip full workspace files
+                    // Truncate if it's important but too long
+                    const maxChars = (soulMaxTokens - soulTokens) * 4;
+                    if (maxChars > 100) {
+                        const truncated = `**${entry.key}:** ${entry.line.slice(entry.key.length + 6, entry.key.length + 6 + maxChars)}…(truncated)`;
+                        sections.soul.push(truncated);
+                        soulTokens += estimateTokens(truncated);
+                    }
+                    continue;
+                }
+                sections.soul.push(entry.line);
+                soulTokens += entry.tokens;
             }
-            // Soul tokens are tracked but don't reduce memory budget
-            tokenBudget = maxTokens; // memory budget is separate from soul
         }
         // --- 1b. Skill assignments (ordered by priority, conflict detection) ---
         if (skillAssignments.length > 0) {
@@ -134,15 +162,27 @@ export class BootstrapMemories extends Resource {
                 memoriesIncluded++;
             }
         }
-        // --- 3. Recent memories (last 24-48h, standard + persistent) ---
-        const sinceDate = since
-            ? new Date(since)
-            : new Date(Date.now() - 48 * 3600_000);
-        const recent = activeMemories
-            .filter((m) => m.durability !== "permanent" &&
-            m.createdAt &&
-            new Date(m.createdAt) >= sinceDate)
+        // --- 3. Recent memories (adaptive window) ---
+        // Start with 48h. If nothing found, widen to 7d, then 30d.
+        // This prevents empty recent sections for agents that were idle.
+        const nonPermanent = activeMemories
+            .filter((m) => m.durability !== "permanent" && m.createdAt)
             .sort((a, b) => (b.createdAt || "").localeCompare(a.createdAt || ""));
+        let effectiveSince;
+        if (since) {
+            effectiveSince = new Date(since);
+        }
+        else {
+            const windows = [48 * 3600_000, 7 * 24 * 3600_000, 30 * 24 * 3600_000];
+            effectiveSince = new Date(Date.now() - windows[0]);
+            for (const w of windows) {
+                effectiveSince = new Date(Date.now() - w);
+                const count = nonPermanent.filter((m) => new Date(m.createdAt) >= effectiveSince).length;
+                if (count >= 3)
+                    break; // found enough recent memories
+            }
+        }
+        const recent = nonPermanent.filter((m) => new Date(m.createdAt) >= effectiveSince);
         // Budget: up to 40% of remaining for recent
         const recentBudget = Math.floor(tokenBudget * 0.4);
         let recentSpent = 0;

package/dist/resources/MemoryMaintenance.js

@@ -0,0 +1,90 @@
+/**
+ * MemoryMaintenance.ts — Maintenance worker for memory hygiene.
+ *
+ * POST /MemoryMaintenance/ — runs cleanup tasks:
+ *   1. Delete expired ephemeral memories (expiresAt < now)
+ *   2. Archive old session memories (> 30 days, standard durability)
+ *   3. Report stats
+ *
+ * Designed to run periodically (daily cron or heartbeat).
+ * Requires admin auth.
+ */
+export default class MemoryMaintenance {
+    static ROUTE = "MemoryMaintenance";
+    static METHOD = "POST";
+    async post(data) {
+        const { databases } = this;
+        const request = this.request;
+        const { dryRun = false, agentId } = data || {};
+        // Scope to authenticated agent. Admin can pass agentId for system-wide
+        // maintenance; non-admin always scoped to their own agent.
+        const authAgent = request?.headers?.get?.("x-tps-agent");
+        const isAdmin = request?.tpsAgentIsAdmin === true;
+        const targetAgent = isAdmin && agentId ? agentId : authAgent;
+        if (!targetAgent && !isAdmin) {
+            return { error: "agentId required" };
+        }
+        const now = new Date();
+        const stats = { expired: 0, archived: 0, total: 0, errors: 0, agent: targetAgent || "all" };
+        try {
+            for await (const record of databases.flair.Memory.search()) {
+                // Skip records not belonging to target agent (unless admin running system-wide)
+                if (targetAgent && record.agentId !== targetAgent)
+                    continue;
+                stats.total++;
+                // 1. Delete expired memories
+                if (record.expiresAt && new Date(record.expiresAt) < now) {
+                    if (!dryRun) {
+                        try {
+                            await databases.flair.Memory.delete(record.id);
+                            stats.expired++;
+                        }
+                        catch {
+                            stats.errors++;
+                        }
+                    }
+                    else {
+                        stats.expired++;
+                    }
+                    continue;
+                }
+                // 2. Archive old standard session memories (> 30 days)
+                // These are low-value session notes that weren't promoted to persistent.
+                // Archiving removes them from search results but keeps the data.
+                if (record.durability === "standard" &&
+                    record.type === "session" &&
+                    !record.archived &&
+                    record.createdAt) {
+                    const ageMs = now.getTime() - new Date(record.createdAt).getTime();
+                    const ageDays = ageMs / (24 * 3600_000);
+                    if (ageDays > 30) {
+                        if (!dryRun) {
+                            try {
+                                // Soft archive — set archived flag, keep data
+                                await databases.flair.Memory.update(record.id, {
+                                    ...record,
+                                    archived: true,
+                                    archivedAt: now.toISOString(),
+                                });
+                                stats.archived++;
+                            }
+                            catch {
+                                stats.errors++;
+                            }
+                        }
+                        else {
+                            stats.archived++;
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            return { error: err.message, stats };
+        }
+        return {
+            message: dryRun ? "Dry run complete" : "Maintenance complete",
+            stats,
+        };
+    }
+}

package/dist/resources/SemanticSearch.js

@@ -44,7 +44,7 @@ function compositeScore(semanticScore, record) {
 }
 export class SemanticSearch extends Resource {
     async post(data) {
-        const { agentId, q, queryEmbedding, tag, subject, subjects, limit = 10, includeSuperseded = false, scoring = "composite" } = data || {};
+        const { agentId, q, queryEmbedding, tag, subject, subjects, limit = 10, includeSuperseded = false, scoring = "composite", minScore = 0, since } = data || {};
         const subjectFilter = subjects
             ? new Set(subjects.map((s) => s.toLowerCase()))
             : subject
@@ -86,6 +86,39 @@ export class SemanticSearch extends Resource {
                 catch { }
             }
         }
+        // ─── Temporal intent detection ────────────────────────────────────────────
+        // If the query implies a time window and no explicit `since` was provided,
+        // auto-detect and apply a recency boost.
+        let sinceDate = since ? new Date(since) : null;
+        let temporalBoost = 1.0;
+        if (q && !sinceDate) {
+            const lq = String(q).toLowerCase();
+            if (/\btoday\b|\bthis morning\b|\bthis afternoon\b/.test(lq)) {
+                const d = new Date();
+                d.setHours(0, 0, 0, 0);
+                sinceDate = d;
+                temporalBoost = 1.5; // boost recent results for temporal queries
+            }
+            else if (/\byesterday\b/.test(lq)) {
+                const d = new Date();
+                d.setDate(d.getDate() - 1);
+                d.setHours(0, 0, 0, 0);
+                sinceDate = d;
+                temporalBoost = 1.3;
+            }
+            else if (/\bthis week\b|\blast few days\b/.test(lq)) {
+                sinceDate = new Date(Date.now() - 7 * 24 * 3600_000);
+                temporalBoost = 1.2;
+            }
+            else if (/\blast week\b/.test(lq)) {
+                sinceDate = new Date(Date.now() - 14 * 24 * 3600_000);
+                temporalBoost = 1.1;
+            }
+            else if (/\brecently\b|\blately\b/.test(lq)) {
+                sinceDate = new Date(Date.now() - 3 * 24 * 3600_000);
+                temporalBoost = 1.3;
+            }
+        }
         const results = [];
         // Iterate ALL memories, filter by agent ID set
         for await (const record of databases.flair.Memory.search()) {
@@ -95,24 +128,34 @@ export class SemanticSearch extends Resource {
                     continue;
             }
             if (record.archived === true)
-                continue; // soft-deleted — excluded from search by default
+                continue;
             if (record.expiresAt && Date.parse(record.expiresAt) < Date.now())
                 continue;
             if (tag && !(record.tags || []).includes(tag))
                 continue;
             if (subjectFilter && record.subject && !subjectFilter.has(String(record.subject).toLowerCase()))
                 continue;
-            let rawScore = 0;
+            // Time window filter
+            if (sinceDate && record.createdAt && new Date(record.createdAt) < sinceDate)
+                continue;
+            let semanticScore = 0;
+            let keywordHit = false;
             if (q && String(record.content || "").toLowerCase().includes(String(q).toLowerCase())) {
-                rawScore += 0.5;
+                keywordHit = true;
             }
             if (qEmb && record.embedding && qEmb.length === record.embedding.length) {
-                rawScore += cosineSimilarity(qEmb, record.embedding);
+                semanticScore = cosineSimilarity(qEmb, record.embedding);
             }
+            // Keyword match is a small tiebreaker (5%), not a primary signal.
+            // This prevents weak semantic matches from ranking high just because
+            // a query word appears in the content.
+            const rawScore = semanticScore + (keywordHit ? 0.05 : 0);
             if (q && rawScore === 0)
                 continue;
-            // Apply composite scoring (temporal decay + durability + retrieval boost)
-            const finalScore = scoring === "raw" ? rawScore : compositeScore(rawScore, record);
+            // Apply composite scoring (temporal decay + durability + retrieval boost + temporal intent)
+            let finalScore = scoring === "raw" ? rawScore : compositeScore(rawScore, record);
+            if (temporalBoost > 1.0)
+                finalScore *= temporalBoost;
             const { embedding, ...rest } = record;
             results.push({
                 ...rest,
@@ -131,6 +174,10 @@ export class SemanticSearch extends Resource {
             }
             filteredResults = results.filter((r) => !supersededIds.has(r.id));
         }
+        // Apply minimum score filter
+        if (minScore > 0) {
+            filteredResults = filteredResults.filter((r) => r._score >= minScore);
+        }
         filteredResults.sort((a, b) => b._score - a._score);
         const topResults = filteredResults.slice(0, limit);
         // Async hit tracking — don't block the response

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tpsdev-ai/flair",
-  "version": "0.2.0",
-  "description": "Identity, memory, and soul for AI agents. Cryptographic identity (Ed25519), semantic memory with local embeddings, and persistent personality — all in a single process.",
+  "version": "0.3.0",
+  "description": "Identity, memory, and soul for AI agents. Cryptographic identity (Ed25519), semantic memory with local embeddings, and persistent personality \u2014 all in a single process.",
   "type": "module",
   "license": "Apache-2.0",
   "repository": {
@@ -39,13 +39,17 @@
   "scripts": {
     "build": "tsc -p tsconfig.json --noCheck",
     "build:cli": "tsc -p tsconfig.cli.json --noCheck",
+    "prepublishOnly": "npm run build && npm run build:cli",
     "test": "bun test"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "engines": {
     "node": ">=22"
   },
   "dependencies": {
-    "@harperfast/harper": "5.0.0-beta.1",
+    "@harperfast/harper": "5.0.0-beta.4",
     "@node-llama-cpp/mac-arm64-metal": "^3.17.1",
     "commander": "14.0.3",
     "harper-fabric-embeddings": "^0.2.0",
@@ -58,5 +62,9 @@
   },
   "trustedDependencies": [
     "harper-fabric-embeddings"
+  ],
+  "workspaces": [
+    "packages/*",
+    "plugins/*"
   ]
-}
+}

package/resources/MemoryBootstrap.ts

@@ -68,12 +68,24 @@ export class BootstrapMemories extends Resource {
     let memoriesIncluded = 0;
     let memoriesAvailable = 0;
 
-    // --- 1. Soul records (unconditional — not subject to token budget) ---
-    // Soul is who you are. It's not optional context to be trimmed.
-    // Skill assignments (key='skill-assignment') are separated into their own section.
+    // --- 1. Soul records (budgeted — prioritized by key importance) ---
+    // Soul is who you are, but we still need to respect token budgets.
+    // Workspace files (SOUL.md, AGENTS.md) can be massive — they're already
+    // injected by the runtime via workspace context, so we prioritize
+    // concise soul entries over full file dumps.
+    const SOUL_KEY_PRIORITY: Record<string, number> = {
+      role: 0, identity: 1, thinking: 2, communication_style: 3,
+      team: 4, ownership: 5, infrastructure: 6, "user-context": 7,
+      // Full workspace files — lowest priority (runtime already injects these)
+      soul: 90, "workspace-rules": 91,
+    };
+
     const skillAssignments: any[] = [];
+    const soulMaxTokens = Math.floor(maxTokens * 0.4); // 40% of budget for soul
     if (includeSoul) {
       let soulTokens = 0;
+      const soulEntries: { key: string; line: string; tokens: number; priority: number }[] = [];
+
       for await (const record of (databases as any).flair.Soul.search()) {
         if (record.agentId !== agentId) continue;
         if (record.key === "skill-assignment") {
@@ -81,11 +93,30 @@ export class BootstrapMemories extends Resource {
           continue;
         }
         const line = `**${record.key}:** ${record.value}`;
-        sections.soul.push(line);
-        soulTokens += estimateTokens(line);
+        const tokens = estimateTokens(line);
+        const priority = SOUL_KEY_PRIORITY[record.key] ?? 50;
+        soulEntries.push({ key: record.key, line, tokens, priority });
+      }
+
+      // Sort by priority (lower = more important)
+      soulEntries.sort((a, b) => a.priority - b.priority);
+
+      for (const entry of soulEntries) {
+        if (soulTokens + entry.tokens > soulMaxTokens) {
+          // Skip large entries that exceed budget — truncate or skip
+          if (entry.priority >= 90) continue; // skip full workspace files
+          // Truncate if it's important but too long
+          const maxChars = (soulMaxTokens - soulTokens) * 4;
+          if (maxChars > 100) {
+            const truncated = `**${entry.key}:** ${entry.line.slice(entry.key.length + 6, entry.key.length + 6 + maxChars)}…(truncated)`;
+            sections.soul.push(truncated);
+            soulTokens += estimateTokens(truncated);
+          }
+          continue;
+        }
+        sections.soul.push(entry.line);
+        soulTokens += entry.tokens;
       }
-      // Soul tokens are tracked but don't reduce memory budget
-      tokenBudget = maxTokens; // memory budget is separate from soul
     }
 
     // --- 1b. Skill assignments (ordered by priority, conflict detection) ---
@@ -147,19 +178,28 @@ export class BootstrapMemories extends Resource {
       }
     }
 
-    // --- 3. Recent memories (last 24-48h, standard + persistent) ---
-    const sinceDate = since
-      ? new Date(since)
-      : new Date(Date.now() - 48 * 3600_000);
-    const recent = activeMemories
-      .filter(
-        (m) =>
-          m.durability !== "permanent" &&
-          m.createdAt &&
-          new Date(m.createdAt) >= sinceDate
-      )
+    // --- 3. Recent memories (adaptive window) ---
+    // Start with 48h. If nothing found, widen to 7d, then 30d.
+    // This prevents empty recent sections for agents that were idle.
+    const nonPermanent = activeMemories
+      .filter((m) => m.durability !== "permanent" && m.createdAt)
       .sort((a: any, b: any) => (b.createdAt || "").localeCompare(a.createdAt || ""));
 
+    let effectiveSince: Date;
+    if (since) {
+      effectiveSince = new Date(since);
+    } else {
+      const windows = [48 * 3600_000, 7 * 24 * 3600_000, 30 * 24 * 3600_000];
+      effectiveSince = new Date(Date.now() - windows[0]);
+      for (const w of windows) {
+        effectiveSince = new Date(Date.now() - w);
+        const count = nonPermanent.filter((m) => new Date(m.createdAt!) >= effectiveSince).length;
+        if (count >= 3) break; // found enough recent memories
+      }
+    }
+
+    const recent = nonPermanent.filter((m) => new Date(m.createdAt!) >= effectiveSince);
+
     // Budget: up to 40% of remaining for recent
     const recentBudget = Math.floor(tokenBudget * 0.4);
     let recentSpent = 0;

package/resources/MemoryMaintenance.ts

@@ -0,0 +1,95 @@
+/**
+ * MemoryMaintenance.ts — Maintenance worker for memory hygiene.
+ *
+ * POST /MemoryMaintenance/ — runs cleanup tasks:
+ *   1. Delete expired ephemeral memories (expiresAt < now)
+ *   2. Archive old session memories (> 30 days, standard durability)
+ *   3. Report stats
+ *
+ * Designed to run periodically (daily cron or heartbeat).
+ * Requires admin auth.
+ */
+
+export default class MemoryMaintenance {
+  static ROUTE = "MemoryMaintenance";
+  static METHOD = "POST";
+
+  async post(data: any) {
+    const { databases }: any = this;
+    const request = (this as any).request;
+    const { dryRun = false, agentId } = data || {};
+
+    // Scope to authenticated agent. Admin can pass agentId for system-wide
+    // maintenance; non-admin always scoped to their own agent.
+    const authAgent = request?.headers?.get?.("x-tps-agent");
+    const isAdmin = (request as any)?.tpsAgentIsAdmin === true;
+    const targetAgent = isAdmin && agentId ? agentId : authAgent;
+
+    if (!targetAgent && !isAdmin) {
+      return { error: "agentId required" };
+    }
+
+    const now = new Date();
+    const stats = { expired: 0, archived: 0, total: 0, errors: 0, agent: targetAgent || "all" };
+
+    try {
+      for await (const record of (databases as any).flair.Memory.search()) {
+        // Skip records not belonging to target agent (unless admin running system-wide)
+        if (targetAgent && record.agentId !== targetAgent) continue;
+        stats.total++;
+
+        // 1. Delete expired memories
+        if (record.expiresAt && new Date(record.expiresAt) < now) {
+          if (!dryRun) {
+            try {
+              await (databases as any).flair.Memory.delete(record.id);
+              stats.expired++;
+            } catch {
+              stats.errors++;
+            }
+          } else {
+            stats.expired++;
+          }
+          continue;
+        }
+
+        // 2. Archive old standard session memories (> 30 days)
+        // These are low-value session notes that weren't promoted to persistent.
+        // Archiving removes them from search results but keeps the data.
+        if (
+          record.durability === "standard" &&
+          record.type === "session" &&
+          !record.archived &&
+          record.createdAt
+        ) {
+          const ageMs = now.getTime() - new Date(record.createdAt).getTime();
+          const ageDays = ageMs / (24 * 3600_000);
+          if (ageDays > 30) {
+            if (!dryRun) {
+              try {
+                // Soft archive — set archived flag, keep data
+                await (databases as any).flair.Memory.update(record.id, {
+                  ...record,
+                  archived: true,
+                  archivedAt: now.toISOString(),
+                });
+                stats.archived++;
+              } catch {
+                stats.errors++;
+              }
+            } else {
+              stats.archived++;
+            }
+          }
+        }
+      }
+    } catch (err: any) {
+      return { error: err.message, stats };
+    }
+
+    return {
+      message: dryRun ? "Dry run complete" : "Maintenance complete",
+      stats,
+    };
+  }
+}

package/resources/SemanticSearch.ts

@@ -52,7 +52,7 @@ function compositeScore(
 
 export class SemanticSearch extends Resource {
   async post(data: any) {
-    const { agentId, q, queryEmbedding, tag, subject, subjects, limit = 10, includeSuperseded = false, scoring = "composite" } = data || {};
+    const { agentId, q, queryEmbedding, tag, subject, subjects, limit = 10, includeSuperseded = false, scoring = "composite", minScore = 0, since } = data || {};
     const subjectFilter = subjects
       ? new Set((subjects as string[]).map((s: string) => s.toLowerCase()))
       : subject
@@ -94,6 +94,33 @@ export class SemanticSearch extends Resource {
       }
     }
 
+    // ─── Temporal intent detection ────────────────────────────────────────────
+    // If the query implies a time window and no explicit `since` was provided,
+    // auto-detect and apply a recency boost.
+    let sinceDate: Date | null = since ? new Date(since) : null;
+    let temporalBoost = 1.0;
+    if (q && !sinceDate) {
+      const lq = String(q).toLowerCase();
+      if (/\btoday\b|\bthis morning\b|\bthis afternoon\b/.test(lq)) {
+        const d = new Date(); d.setHours(0, 0, 0, 0);
+        sinceDate = d;
+        temporalBoost = 1.5; // boost recent results for temporal queries
+      } else if (/\byesterday\b/.test(lq)) {
+        const d = new Date(); d.setDate(d.getDate() - 1); d.setHours(0, 0, 0, 0);
+        sinceDate = d;
+        temporalBoost = 1.3;
+      } else if (/\bthis week\b|\blast few days\b/.test(lq)) {
+        sinceDate = new Date(Date.now() - 7 * 24 * 3600_000);
+        temporalBoost = 1.2;
+      } else if (/\blast week\b/.test(lq)) {
+        sinceDate = new Date(Date.now() - 14 * 24 * 3600_000);
+        temporalBoost = 1.1;
+      } else if (/\brecently\b|\blately\b/.test(lq)) {
+        sinceDate = new Date(Date.now() - 3 * 24 * 3600_000);
+        temporalBoost = 1.3;
+      }
+    }
+
     const results: any[] = [];
 
     // Iterate ALL memories, filter by agent ID set
@@ -103,22 +130,30 @@ export class SemanticSearch extends Resource {
         if (record.visibility !== "office") continue;
       }
 
-      if (record.archived === true) continue; // soft-deleted — excluded from search by default
+      if (record.archived === true) continue;
       if (record.expiresAt && Date.parse(record.expiresAt) < Date.now()) continue;
       if (tag && !(record.tags || []).includes(tag)) continue;
       if (subjectFilter && record.subject && !subjectFilter.has(String(record.subject).toLowerCase())) continue;
+      // Time window filter
+      if (sinceDate && record.createdAt && new Date(record.createdAt) < sinceDate) continue;
 
-      let rawScore = 0;
+      let semanticScore = 0;
+      let keywordHit = false;
       if (q && String(record.content || "").toLowerCase().includes(String(q).toLowerCase())) {
-        rawScore += 0.5;
+        keywordHit = true;
       }
       if (qEmb && record.embedding && qEmb.length === record.embedding.length) {
-        rawScore += cosineSimilarity(qEmb, record.embedding);
+        semanticScore = cosineSimilarity(qEmb, record.embedding);
       }
+      // Keyword match is a small tiebreaker (5%), not a primary signal.
+      // This prevents weak semantic matches from ranking high just because
+      // a query word appears in the content.
+      const rawScore = semanticScore + (keywordHit ? 0.05 : 0);
       if (q && rawScore === 0) continue;
 
-      // Apply composite scoring (temporal decay + durability + retrieval boost)
-      const finalScore = scoring === "raw" ? rawScore : compositeScore(rawScore, record);
+      // Apply composite scoring (temporal decay + durability + retrieval boost + temporal intent)
+      let finalScore = scoring === "raw" ? rawScore : compositeScore(rawScore, record);
+      if (temporalBoost > 1.0) finalScore *= temporalBoost;
 
       const { embedding, ...rest } = record;
       results.push({
@@ -139,6 +174,11 @@ export class SemanticSearch extends Resource {
       filteredResults = results.filter((r: any) => !supersededIds.has(r.id));
     }
 
+    // Apply minimum score filter
+    if (minScore > 0) {
+      filteredResults = filteredResults.filter((r: any) => r._score >= minScore);
+    }
+
     filteredResults.sort((a: any, b: any) => b._score - a._score);
     const topResults = filteredResults.slice(0, limit);