@phren/cli 0.0.5 → 0.0.6

package/mcp/dist/cli-hooks.js

@@ -150,6 +150,26 @@ export async function handleHookPrompt() {
     if (!keywords)
         process.exit(0);
     debugLog(`hook-prompt keywords: "${keywords}"`);
+    // Session momentum: track topic frequencies within the session
+    let hotTopics = [];
+    if (sessionId) {
+        const topicFile = sessionMarker(getPhrenPath(), `topics-${sessionId}.json`);
+        let sessionTopics = {};
+        try {
+            if (fs.existsSync(topicFile)) {
+                sessionTopics = JSON.parse(fs.readFileSync(topicFile, 'utf8'));
+            }
+        }
+        catch { /* ignore parse errors */ }
+        for (const kw of keywordEntries) {
+            sessionTopics[kw] = (sessionTopics[kw] ?? 0) + 1;
+        }
+        fs.writeFileSync(topicFile, JSON.stringify(sessionTopics));
+        // Find hot topics (3+ mentions this session)
+        hotTopics = Object.entries(sessionTopics)
+            .filter(([, count]) => count >= 3)
+            .map(([topic]) => topic);
+    }
     const tIndex0 = Date.now();
     const db = await buildIndex(getPhrenPath(), profile);
     stage.indexMs = Date.now() - tIndex0;
@@ -197,20 +217,18 @@ export async function handleHookPrompt() {
         stage.rankMs = Date.now() - tRank0;
         if (!rows.length)
             process.exit(0);
-        const safeTokenBudget = clampInt(process.env.PHREN_CONTEXT_TOKEN_BUDGET, 550, 180, 10000);
+        let safeTokenBudget = clampInt(process.env.PHREN_CONTEXT_TOKEN_BUDGET, 550, 180, 10000);
         const safeLineBudget = clampInt(process.env.PHREN_CONTEXT_SNIPPET_LINES, 6, 2, 100);
         const safeCharBudget = clampInt(process.env.PHREN_CONTEXT_SNIPPET_CHARS, 520, 120, 10000);
+        // Session momentum: boost token budget for hot topics
+        if (hotTopics.length > 0) {
+            safeTokenBudget = Math.min(Math.floor(safeTokenBudget * 1.3), parseInt(process.env.PHREN_MAX_INJECT_TOKENS ?? '2000', 10));
+        }
         const tSelect0 = Date.now();
         const { selected, usedTokens } = selectSnippets(rows, keywords, safeTokenBudget, safeLineBudget, safeCharBudget);
         stage.selectMs = Date.now() - tSelect0;
         if (!selected.length)
             process.exit(0);
-        // Log query-to-finding correlations for future pre-warming (gated by env var)
-        try {
-            const { logCorrelations: logCorr } = await import("./query-correlation.js");
-            logCorr(getPhrenPath(), keywords, selected, sessionId);
-        }
-        catch { /* non-fatal */ }
         // Injection budget: cap total injected tokens across all content
         const maxInjectTokens = clampInt(process.env.PHREN_MAX_INJECT_TOKENS, 2000, 200, 20000);
         let budgetSelected = selected;

package/mcp/dist/content-citation.js

@@ -5,7 +5,7 @@ import { debugLog, EXEC_TIMEOUT_MS, EXEC_TIMEOUT_QUICK_MS } from "./shared.js";
 import { errorMessage, runGitOrThrow } from "./utils.js";
 import { findingIdFromLine } from "./finding-impact.js";
 import { METADATA_REGEX, isArchiveStart, isArchiveEnd } from "./content-metadata.js";
-import { FINDING_TYPE_DECAY, extractFindingType } from "./finding-lifecycle.js";
+import { FINDING_TYPE_DECAY, extractFindingType, parseFindingLifecycle } from "./finding-lifecycle.js";
 export const FINDING_PROVENANCE_SOURCES = [
     "human",
     "agent",
@@ -294,6 +294,7 @@ export function filterTrustedFindingsDetailed(content, opts) {
         ...(options.decay || {}),
     };
     const highImpactFindingIds = options.highImpactFindingIds;
+    const impactCounts = options.impactCounts;
     const project = options.project;
     const lines = content.split("\n");
     const out = [];
@@ -412,9 +413,29 @@ export function filterTrustedFindingsDetailed(content, opts) {
             confidence *= 0.9;
         if (project && highImpactFindingIds?.size) {
             const findingId = findingIdFromLine(line);
-            if (highImpactFindingIds.has(findingId))
-                confidence *= 1.15;
+            if (highImpactFindingIds.has(findingId)) {
+                // Get surface count for graduated boost
+                const surfaceCount = impactCounts?.get(findingId) ?? 3;
+                // Log-scaled: 3→1.15x, 10→1.28x, 30→1.38x, capped at 1.4x
+                const boost = Math.min(1.4, 1 + 0.1 * Math.log2(Math.max(3, surfaceCount)));
+                confidence *= boost;
+                // Decay resistance: confirmed findings decay 3x slower
+                if (effectiveDate) {
+                    const realAge = ageDaysForDate(effectiveDate);
+                    if (realAge !== null) {
+                        const slowedAge = Math.floor(realAge / 3);
+                        confidence = Math.max(confidence, confidenceForAge(slowedAge, decay));
+                    }
+                }
+            }
         }
+        const lifecycle = parseFindingLifecycle(line);
+        if (lifecycle?.status === "superseded")
+            confidence *= 0.25;
+        if (lifecycle?.status === "retracted")
+            confidence *= 0.1;
+        if (lifecycle?.status === "contradicted")
+            confidence *= 0.4;
         confidence = Math.max(0, Math.min(1, confidence));
         if (confidence < minConfidence) {
             issues.push({ date: effectiveDate || "unknown", bullet: line, reason: "stale" });

package/mcp/dist/content-learning.js

@@ -11,7 +11,7 @@ import { isDuplicateFinding, scanForSecrets, normalizeObservationTags, resolveCo
 import { validateFindingsFormat, validateFinding } from "./content-validate.js";
 import { countActiveFindings, autoArchiveToReference } from "./content-archive.js";
 import { resolveAutoFindingTaskItem, resolveFindingTaskReference, resolveFindingSessionId, } from "./finding-context.js";
-import { buildLifecycleComments, parseFindingLifecycle, stripLifecycleComments, } from "./finding-lifecycle.js";
+import { buildLifecycleComments, extractFindingType, parseFindingLifecycle, stripLifecycleComments, } from "./finding-lifecycle.js";
 import { METADATA_REGEX, } from "./content-metadata.js";
 /** Default cap for active findings before auto-archiving is triggered. */
 const DEFAULT_FINDINGS_CAP = 20;
@@ -107,6 +107,22 @@ function resolveFindingCitationInput(phrenPath, project, citationInput) {
     }
     return phrenOk(Object.keys(resolved).length > 0 ? resolved : undefined);
 }
+export function autoDetectFindingType(text) {
+    const lower = text.toLowerCase();
+    if (/\b(we decided|decision:|chose .+ over|went with)\b/.test(lower))
+        return 'decision';
+    if (/\b(bug:|bug in|found a bug|broken|crashes|fails when)\b/.test(lower))
+        return 'bug';
+    if (/\b(workaround:|work around|temporary fix|hack:)\b/.test(lower))
+        return 'workaround';
+    if (/\b(pattern:|always .+ before|never .+ without|best practice)\b/.test(lower))
+        return 'pattern';
+    if (/\b(pitfall:|gotcha:|watch out|careful with|trap:)\b/.test(lower))
+        return 'pitfall';
+    if (/\b(currently|as of|right now|at the moment|observation:)\b/.test(lower))
+        return 'context';
+    return null;
+}
 function prepareFinding(learning, project, fullHistory, extraAnnotations, citationInput, source, nowIso, inferredRepo, headCommit, phrenPath) {
     const secretType = scanForSecrets(learning);
     if (secretType) {
@@ -114,10 +130,17 @@ function prepareFinding(learning, project, fullHistory, extraAnnotations, citati
     }
     const today = (nowIso ?? new Date().toISOString()).slice(0, 10);
     const { text: tagNormalized, warning: tagWarning } = normalizeObservationTags(learning);
-    const normalizedLearning = resolveCoref(tagNormalized, {
+    let normalizedLearning = resolveCoref(tagNormalized, {
         project,
         file: citationInput?.file,
     });
+    const existingType = extractFindingType('- ' + normalizedLearning);
+    if (!existingType) {
+        const detected = autoDetectFindingType(normalizedLearning);
+        if (detected) {
+            normalizedLearning = `[${detected}] ${normalizedLearning}`;
+        }
+    }
     const fid = crypto.randomBytes(4).toString("hex");
     const fidComment = `<!-- fid:${fid} -->`;
     const createdComment = `<!-- created: ${today} -->`;

package/mcp/dist/data-access.js

@@ -54,6 +54,46 @@ function normalizeFindingGroupKey(item) {
 function findingTimelineDate(item) {
     return item.status_updated || item.date || "0000-00-00";
 }
+function collectFindingBulletLines(lines) {
+    const bulletLines = [];
+    let inArchiveBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (isArchiveStart(line)) {
+            inArchiveBlock = true;
+            continue;
+        }
+        if (isArchiveEnd(line)) {
+            inArchiveBlock = false;
+            continue;
+        }
+        if (!line.startsWith("- "))
+            continue;
+        bulletLines.push({ line, i, archived: inArchiveBlock });
+    }
+    return bulletLines;
+}
+function findMatchingFindingBullet(bulletLines, needle, match) {
+    const fidNeedle = needle.replace(/^fid:/, "");
+    const fidMatch = /^[a-z0-9]{8}$/.test(fidNeedle)
+        ? bulletLines.filter(({ line }) => new RegExp(`<!--\\s*fid:${fidNeedle}\\s*-->`).test(line))
+        : [];
+    const exactMatches = bulletLines.filter(({ line }) => line.replace(/^-\s+/, "").replace(/<!--.*?-->/g, "").trim().toLowerCase() === needle);
+    const partialMatches = bulletLines.filter(({ line }) => line.toLowerCase().includes(needle));
+    if (fidMatch.length === 1)
+        return { kind: "found", idx: fidMatch[0].i };
+    if (exactMatches.length === 1)
+        return { kind: "found", idx: exactMatches[0].i };
+    if (exactMatches.length > 1) {
+        return { kind: "ambiguous", error: `"${match}" is ambiguous (${exactMatches.length} exact matches). Use a more specific phrase.` };
+    }
+    if (partialMatches.length === 1)
+        return { kind: "found", idx: partialMatches[0].i };
+    if (partialMatches.length > 1) {
+        return { kind: "ambiguous", error: `"${match}" is ambiguous (${partialMatches.length} partial matches). Use a more specific phrase.` };
+    }
+    return { kind: "not_found" };
+}
 export function readFindings(phrenPath, project, opts = {}) {
     const ensured = ensureProject(phrenPath, project);
     if (!ensured.ok)
@@ -210,35 +250,19 @@ export function removeFinding(phrenPath, project, match) {
     return withSafeLock(filePath, () => {
         const lines = fs.readFileSync(filePath, "utf8").split("\n");
         const needle = match.trim().toLowerCase();
-        const bulletLines = lines.map((line, i) => ({ line, i })).filter(({ line }) => line.startsWith("- "));
-        // 0) Stable finding ID match (fid:XXXXXXXX or just the 8-char hex)
-        const fidNeedle = needle.replace(/^fid:/, "");
-        const fidMatch = /^[a-z0-9]{8}$/.test(fidNeedle)
-            ? bulletLines.filter(({ line }) => new RegExp(`<!--\\s*fid:${fidNeedle}\\s*-->`).test(line))
-            : [];
-        // 1) Exact text match (strip bullet prefix + metadata for comparison)
-        const exactMatches = bulletLines.filter(({ line }) => line.replace(/^-\s+/, "").replace(/<!--.*?-->/g, "").trim().toLowerCase() === needle);
-        // 2) Unique partial substring match
-        const partialMatches = bulletLines.filter(({ line }) => line.toLowerCase().includes(needle));
-        let idx;
-        if (fidMatch.length === 1) {
-            idx = fidMatch[0].i;
-        }
-        else if (exactMatches.length === 1) {
-            idx = exactMatches[0].i;
-        }
-        else if (exactMatches.length > 1) {
-            return phrenErr(`"${match}" is ambiguous (${exactMatches.length} exact matches). Use a more specific phrase.`, PhrenError.AMBIGUOUS_MATCH);
-        }
-        else if (partialMatches.length === 1) {
-            idx = partialMatches[0].i;
-        }
-        else if (partialMatches.length > 1) {
-            return phrenErr(`"${match}" is ambiguous (${partialMatches.length} partial matches). Use a more specific phrase.`, PhrenError.AMBIGUOUS_MATCH);
+        const bulletLines = collectFindingBulletLines(lines);
+        const activeMatch = findMatchingFindingBullet(bulletLines.filter(({ archived }) => !archived), needle, match);
+        if (activeMatch.kind === "ambiguous") {
+            return phrenErr(activeMatch.error, PhrenError.AMBIGUOUS_MATCH);
         }
-        else {
+        if (activeMatch.kind === "not_found") {
+            const archivedMatch = findMatchingFindingBullet(bulletLines.filter(({ archived }) => archived), needle, match);
+            if (archivedMatch.kind === "ambiguous" || archivedMatch.kind === "found") {
+                return phrenErr(`Finding "${match}" is archived and read-only. Restore or re-add it before mutating history.`, PhrenError.VALIDATION_ERROR);
+            }
             return phrenErr(`No finding matching "${match}" in project "${project}". Try a different search term or check :findings view.`, PhrenError.NOT_FOUND);
         }
+        const idx = activeMatch.idx;
         const removeCount = isCitationLine(lines[idx + 1] || "") ? 2 : 1;
         const matched = lines[idx];
         lines.splice(idx, removeCount);
@@ -260,33 +284,19 @@ export function editFinding(phrenPath, project, oldText, newText) {
     return withSafeLock(findingsPath, () => {
         const lines = fs.readFileSync(findingsPath, "utf8").split("\n");
         const needle = oldText.trim().toLowerCase();
-        const bulletLines = lines.map((line, i) => ({ line, i })).filter(({ line }) => line.startsWith("- "));
-        // Stable finding ID match
-        const fidNeedle = needle.replace(/^fid:/, "");
-        const fidMatch = /^[a-z0-9]{8}$/.test(fidNeedle)
-            ? bulletLines.filter(({ line }) => new RegExp(`<!--\\s*fid:${fidNeedle}\\s*-->`).test(line))
-            : [];
-        const exactMatches = bulletLines.filter(({ line }) => line.replace(/^-\s+/, "").replace(/<!--.*?-->/g, "").trim().toLowerCase() === needle);
-        const partialMatches = bulletLines.filter(({ line }) => line.toLowerCase().includes(needle));
-        let idx;
-        if (fidMatch.length === 1) {
-            idx = fidMatch[0].i;
-        }
-        else if (exactMatches.length === 1) {
-            idx = exactMatches[0].i;
-        }
-        else if (exactMatches.length > 1) {
-            return phrenErr(`"${oldText}" is ambiguous (${exactMatches.length} exact matches). Use a more specific phrase.`, PhrenError.AMBIGUOUS_MATCH);
+        const bulletLines = collectFindingBulletLines(lines);
+        const activeMatch = findMatchingFindingBullet(bulletLines.filter(({ archived }) => !archived), needle, oldText);
+        if (activeMatch.kind === "ambiguous") {
+            return phrenErr(activeMatch.error, PhrenError.AMBIGUOUS_MATCH);
         }
-        else if (partialMatches.length === 1) {
-            idx = partialMatches[0].i;
-        }
-        else if (partialMatches.length > 1) {
-            return phrenErr(`"${oldText}" is ambiguous (${partialMatches.length} partial matches). Use a more specific phrase.`, PhrenError.AMBIGUOUS_MATCH);
-        }
-        else {
+        if (activeMatch.kind === "not_found") {
+            const archivedMatch = findMatchingFindingBullet(bulletLines.filter(({ archived }) => archived), needle, oldText);
+            if (archivedMatch.kind === "ambiguous" || archivedMatch.kind === "found") {
+                return phrenErr(`Finding "${oldText}" is archived and read-only. Restore or re-add it before mutating history.`, PhrenError.VALIDATION_ERROR);
+            }
             return phrenErr(`No finding matching "${oldText}" in project "${project}".`, PhrenError.NOT_FOUND);
         }
+        const idx = activeMatch.idx;
         // Preserve existing metadata comment (fid, citations, etc.)
         const existing = lines[idx];
         const metaMatch = existing.match(/(<!--.*?-->)/g);

package/mcp/dist/finding-impact.js

@@ -144,6 +144,29 @@ export function getHighImpactFindings(phrenPath, minSurfaceCount = 3) {
     };
     return new Set(ids);
 }
+export function getImpactSurfaceCounts(phrenPath, minSurfaces = 1) {
+    const file = impactLogFile(phrenPath);
+    if (!fs.existsSync(file))
+        return new Map();
+    const lines = fs.readFileSync(file, "utf8").split("\n").filter(Boolean);
+    const counts = new Map();
+    for (const line of lines) {
+        try {
+            const entry = JSON.parse(line);
+            if (entry.findingId) {
+                counts.set(entry.findingId, (counts.get(entry.findingId) ?? 0) + 1);
+            }
+        }
+        catch { }
+    }
+    // Filter by minimum
+    const filtered = new Map();
+    for (const [id, count] of counts) {
+        if (count >= minSurfaces)
+            filtered.set(id, count);
+    }
+    return filtered;
+}
 export function markImpactEntriesCompletedForSession(phrenPath, sessionId, project) {
     if (!sessionId)
         return 0;

package/mcp/dist/mcp-session.js

@@ -169,7 +169,7 @@ function findMostRecentSummaryWithProject(phrenPath) {
         if (fs.existsSync(fastPath)) {
             const data = JSON.parse(fs.readFileSync(fastPath, "utf-8"));
             if (data.summary)
-                return { summary: data.summary, project: data.project };
+                return { summary: data.summary, project: data.project, endedAt: data.endedAt };
         }
     }
     catch (err) {
@@ -181,7 +181,7 @@ function findMostRecentSummaryWithProject(phrenPath) {
     if (results.length === 0)
         return { summary: null };
     const best = results[0]; // already sorted newest-mtime-first
-    return { summary: best.data.summary, project: best.data.project };
+    return { summary: best.data.summary, project: best.data.project, endedAt: best.data.endedAt };
 }
 /** Resolve session file from an explicit sessionId or a previously-bound connectionId. */
 function resolveSessionFile(phrenPath, sessionId, connectionId) {
@@ -338,6 +338,45 @@ function hasCompletedTasksInSession(phrenPath, sessionId, project) {
     const artifacts = getSessionArtifacts(phrenPath, sessionId, project);
     return artifacts.tasks.some((task) => task.section === "Done" && task.checked);
 }
+/** Compute what changed since the last session ended. */
+export function computeSessionDiff(phrenPath, project, lastSessionEnd) {
+    const projectDir = path.join(phrenPath, project);
+    const findingsPath = path.join(projectDir, "FINDINGS.md");
+    if (!fs.existsSync(findingsPath))
+        return { newFindings: 0, superseded: 0, tasksCompleted: 0 };
+    const content = fs.readFileSync(findingsPath, "utf8");
+    const lines = content.split("\n");
+    let currentDate = null;
+    let newFindings = 0;
+    let superseded = 0;
+    const cutoff = lastSessionEnd.slice(0, 10);
+    for (const line of lines) {
+        const dateMatch = line.match(/^## (\d{4}-\d{2}-\d{2})$/);
+        if (dateMatch) {
+            currentDate = dateMatch[1];
+            continue;
+        }
+        if (!line.startsWith("- ") || !currentDate)
+            continue;
+        if (currentDate >= cutoff) {
+            newFindings++;
+            if (line.includes('status "superseded"'))
+                superseded++;
+        }
+    }
+    // Count completed tasks since last session
+    const tasksPath = path.join(projectDir, "TASKS.md");
+    let tasksCompleted = 0;
+    if (fs.existsSync(tasksPath)) {
+        const taskContent = fs.readFileSync(tasksPath, "utf8");
+        const doneMatch = taskContent.match(/## Done[\s\S]*/);
+        if (doneMatch) {
+            const doneLines = doneMatch[0].split("\n").filter(l => l.startsWith("- "));
+            tasksCompleted = doneLines.length;
+        }
+    }
+    return { newFindings, superseded, tasksCompleted };
+}
 export function register(server, ctx) {
     const { phrenPath } = ctx;
     server.registerTool("session_start", {
@@ -364,6 +403,7 @@ export function register(server, ctx) {
         const priorEnded = prior ? null : findMostRecentSummaryWithProject(phrenPath);
         const priorSummary = prior?.summary ?? priorEnded?.summary ?? null;
         const priorProject = prior?.project ?? priorEnded?.project;
+        const priorEndedAt = prior?.endedAt ?? priorEnded?.endedAt;
         // Create new session with unique ID in its own file
         const sessionId = crypto.randomUUID();
         const next = {
@@ -447,6 +487,25 @@ export function register(server, ctx) {
                 debugError("session_start checkpointsRead", err);
             }
         }
+        // Compute context diff since last session
+        if (activeProject && isValidProjectName(activeProject) && priorEndedAt) {
+            try {
+                const diff = computeSessionDiff(phrenPath, activeProject, priorEndedAt);
+                if (diff.newFindings > 0 || diff.superseded > 0 || diff.tasksCompleted > 0) {
+                    const diffParts = [];
+                    if (diff.newFindings > 0)
+                        diffParts.push(`${diff.newFindings} new finding${diff.newFindings === 1 ? "" : "s"}`);
+                    if (diff.superseded > 0)
+                        diffParts.push(`${diff.superseded} superseded`);
+                    if (diff.tasksCompleted > 0)
+                        diffParts.push(`${diff.tasksCompleted} task${diff.tasksCompleted === 1 ? "" : "s"} in done`);
+                    parts.push(`## Since last session\n${diffParts.join(", ")}.`);
+                }
+            }
+            catch (err) {
+                debugError("session_start contextDiff", err);
+            }
+        }
         const message = parts.length > 0
             ? `Session started (${sessionId.slice(0, 8)}).\n\n${parts.join("\n\n")}`
             : `Session started (${sessionId.slice(0, 8)}). No prior context found.`;

package/mcp/dist/memory-ui-data.js

@@ -8,7 +8,7 @@ import { readCustomHooks } from "./hooks.js";
 import { hookConfigPaths, hookConfigRoots } from "./provider-adapters.js";
 import { getAllSkills } from "./skill-registry.js";
 import { resolveTaskFilePath, readTasks, TASKS_FILENAME } from "./data-tasks.js";
-import { buildIndex, queryRows } from "./shared-index.js";
+import { buildIndex, queryDocBySourceKey, queryRows } from "./shared-index.js";
 import { readProjectTopics, classifyTopicForText } from "./project-topics.js";
 import { entryScoreKey } from "./governance-scores.js";
 function extractGithubUrl(content) {
@@ -271,10 +271,9 @@ export async function buildGraph(phrenPath, profile, focusProject) {
         const rows = queryRows(db, `SELECT e.id, e.name, e.type, COUNT(DISTINCT el.source_doc) as ref_count
        FROM entities e JOIN entity_links el ON el.target_id = e.id WHERE e.type != 'document'
        GROUP BY e.id, e.name, e.type ORDER BY ref_count DESC LIMIT 500`, []);
-        const refRows = queryRows(db, `SELECT e.id, el.source_doc, d.content, d.filename
+        const refRows = queryRows(db, `SELECT e.id, el.source_doc
        FROM entities e
        JOIN entity_links el ON el.target_id = e.id
-       LEFT JOIN docs d ON d.source_key = el.source_doc
        WHERE e.type != 'document'`, []);
         const refsByEntity = new Map();
         const seenEntityDoc = new Set();
@@ -291,8 +290,9 @@ export async function buildGraph(phrenPath, profile, focusProject) {
                     continue;
                 seenEntityDoc.add(entityDocKey);
                 const project = projectFromSourceDoc(doc);
-                const content = typeof row[2] === "string" ? row[2] : "";
-                const filename = typeof row[3] === "string" ? row[3] : "";
+                const docRow = queryDocBySourceKey(db, phrenPath, doc);
+                const content = docRow?.content ?? "";
+                const filename = docRow?.filename ?? "";
                 const scoreKey = project && filename && content ? entryScoreKey(project, filename, content) : undefined;
                 const refs = refsByEntity.get(entityId) ?? [];
                 refs.push({ doc, project, scoreKey });

package/mcp/dist/shared-content.js

@@ -3,6 +3,6 @@ export { checkConsolidationNeeded, validateFindingsFormat, stripTaskDoneSection,
 export { filterTrustedFindings, filterTrustedFindingsDetailed, } from "./content-citation.js";
 export { scanForSecrets, resolveCoref, isDuplicateFinding, detectConflicts, extractDynamicEntities, checkSemanticDedup, checkSemanticConflicts, } from "./content-dedup.js";
 export { countActiveFindings, autoArchiveToReference, } from "./content-archive.js";
-export { upsertCanonical, addFindingToFile, addFindingsToFile, } from "./content-learning.js";
+export { upsertCanonical, addFindingToFile, addFindingsToFile, autoDetectFindingType, } from "./content-learning.js";
 export { FINDING_LIFECYCLE_STATUSES, FINDING_TYPE_DECAY, extractFindingType, parseFindingLifecycle, buildLifecycleComments, isInactiveFindingLine, } from "./finding-lifecycle.js";
 export { METADATA_REGEX, parseStatus, parseStatusField, parseSupersession, parseSupersedesRef, parseContradiction, parseAllContradictions, parseFindingId, parseCreatedDate, isCitationLine, isArchiveStart, isArchiveEnd, stripLifecycleMetadata, stripRelationMetadata, stripAllMetadata, stripComments, addMetadata, } from "./content-metadata.js";

package/mcp/dist/shared-index.js

@@ -6,12 +6,13 @@ import { globSync } from "glob";
 import { debugLog, appendIndexEvent, getProjectDirs, collectNativeMemoryFiles, runtimeFile, homeDir, readRootManifest, } from "./shared.js";
 import { getIndexPolicy, withFileLock } from "./shared-governance.js";
 import { stripTaskDoneSection } from "./shared-content.js";
+import { isInactiveFindingLine } from "./finding-lifecycle.js";
 import { invalidateDfCache } from "./shared-search-fallback.js";
 import { errorMessage } from "./utils.js";
 import { beginUserFragmentBuildCache, endUserFragmentBuildCache, extractAndLinkFragments, ensureGlobalEntitiesTable, } from "./shared-fragment-graph.js";
 import { bootstrapSqlJs } from "./shared-sqljs.js";
 import { getProjectOwnershipMode, getProjectSourcePath, readProjectConfig } from "./project-config.js";
-import { buildSourceDocKey, queryDocRows, queryRows, } from "./index-query.js";
+import { buildSourceDocKey, queryDocBySourceKey, queryDocRows, } from "./index-query.js";
 import { classifyTopicForText, readProjectTopics, } from "./project-topics.js";
 export { porterStem } from "./shared-stemmer.js";
 export { cosineFallback } from "./shared-search-fallback.js";
@@ -101,6 +102,11 @@ export function classifyFile(filename, relPath) {
 }
 const IMPORT_RE = /^@import\s+(.+)$/gm;
 const MAX_IMPORT_DEPTH = 5;
+const IMPORT_ROOT_PREFIX = "shared/";
+function isAllowedImportPath(importPath) {
+    const normalized = importPath.replace(/\\/g, "/");
+    return normalized.startsWith(IMPORT_ROOT_PREFIX) && normalized.toLowerCase().endsWith(".md");
+}
 /**
  * Internal recursive helper for resolveImports. Tracks `seen` (cycle detection) and `depth` (runaway
  * recursion guard) — callers should never pass these; use the public `resolveImports` instead.
@@ -110,6 +116,9 @@ function _resolveImportsRecursive(content, phrenPath, seen, depth) {
         return content;
     return content.replace(IMPORT_RE, (_match, importPath) => {
         const trimmed = importPath.trim();
+        if (!isAllowedImportPath(trimmed)) {
+            return "<!-- @import blocked: only shared/*.md allowed -->";
+        }
         const globalRoot = path.resolve(phrenPath, "global");
         const resolved = path.join(globalRoot, trimmed);
         // Use lexical resolution first for the prefix check
@@ -464,6 +473,10 @@ export function normalizeIndexedContent(content, type, phrenPath, maxChars) {
     if (type === "task") {
         normalized = stripTaskDoneSection(normalized);
     }
+    if (type === "findings") {
+        const lines = normalized.split("\n");
+        normalized = lines.filter(line => !isInactiveFindingLine(line)).join("\n");
+    }
     if (typeof maxChars === "number" && maxChars >= 0) {
         normalized = normalized.slice(0, maxChars);
     }
@@ -782,8 +795,8 @@ function mergeManualLinks(db, phrenPath) {
         for (const link of manualLinks) {
             try {
                 // Validate: skip manual links whose sourceDoc no longer exists in the index
-                const docCheck = queryRows(db, "SELECT 1 FROM docs WHERE source_key = ? LIMIT 1", [link.sourceDoc]);
-                if (!docCheck || docCheck.length === 0) {
+                const docCheck = queryDocBySourceKey(db, phrenPath, link.sourceDoc);
+                if (!docCheck) {
                     if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
                         process.stderr.write(`[phren] manualLinks: pruning stale link to "${link.sourceDoc}"\n`);
                     pruned = true;

package/mcp/dist/shared-retrieval.js

@@ -3,7 +3,7 @@ import { getQualityMultiplier, entryScoreKey, } from "./shared-governance.js";
 import { queryDocRows, queryRows, cosineFallback, extractSnippet, getDocSourceKey, getEntityBoostDocs, decodeFiniteNumber, rowToDocWithRowid, } from "./shared-index.js";
 import { filterTrustedFindingsDetailed, } from "./shared-content.js";
 import { parseCitationComment } from "./content-citation.js";
-import { getHighImpactFindings } from "./finding-impact.js";
+import { getHighImpactFindings, getImpactSurfaceCounts } from "./finding-impact.js";
 import { buildFtsQueryVariants, buildRelaxedFtsQuery, isFeatureEnabled, STOP_WORDS } from "./utils.js";
 import * as fs from "fs";
 import * as path from "path";
@@ -12,7 +12,6 @@ import { vectorFallback } from "./shared-search-fallback.js";
 import { getOllamaUrl, getCloudEmbeddingUrl } from "./shared-ollama.js";
 import { keywordFallbackSearch } from "./core-search.js";
 import { debugLog } from "./shared.js";
-import { getCorrelatedDocs } from "./query-correlation.js";
 // ── Scoring constants ─────────────────────────────────────────────────────────
 /** Number of docs sampled for token-overlap semantic fallback search. */
 const SEMANTIC_FALLBACK_SAMPLE_LIMIT = 100;
@@ -32,13 +31,13 @@ const LOW_FOCUS_SNIPPET_CHAR_FRACTION = 0.55;
 const TASK_RESCUE_MIN_OVERLAP = 0.3;
 const TASK_RESCUE_OVERLAP_MARGIN = 0.12;
 const TASK_RESCUE_SCORE_MARGIN = 0.6;
-/** Boost applied to docs that correlate with recurring query patterns. */
-const CORRELATION_BOOST = 1.5;
 /** Fraction of bullets that must be low-value before applying the low-value penalty. */
 const LOW_VALUE_BULLET_FRACTION = 0.5;
 // ── Intent and scoring helpers ───────────────────────────────────────────────
 export function detectTaskIntent(prompt) {
     const p = prompt.toLowerCase();
+    if (/\/\w+/.test(p) || /\b(skill|swarm|command|lineup|slash command)\b/.test(p))
+        return "skill";
     if (/(bug|error|fix|broken|regression|fail|stack trace)/.test(p))
         return "debug";
     if (/(review|audit|pr|pull request|nit|refactor)/.test(p))
@@ -50,6 +49,8 @@ export function detectTaskIntent(prompt) {
     return "general";
 }
 function intentBoost(intent, docType) {
+    if (intent === "skill" && docType === "skill")
+        return 4;
     if (intent === "debug" && (docType === "findings" || docType === "reference"))
         return 3;
     if (intent === "review" && (docType === "canonical" || docType === "changelog"))
@@ -346,10 +347,23 @@ export function searchDocuments(db, safeQuery, prompt, keywords, detectedProject
     if (ftsDocs.length === 0 && relaxedQuery && relaxedQuery !== safeQuery) {
         runScopedFtsQuery(relaxedQuery);
     }
+    // Tier 1.5: Fragment graph expansion
+    const fragmentExpansionDocs = [];
+    const queryLower = (prompt + " " + keywords).toLowerCase();
+    const fragmentBoostDocKeys = getEntityBoostDocs(db, queryLower);
+    for (const docKey of fragmentBoostDocKeys) {
+        if (ftsSeenKeys.has(docKey))
+            continue;
+        const rows = queryDocRows(db, "SELECT project, filename, type, content, path FROM docs WHERE path = ? LIMIT 1", [docKey]);
+        if (rows?.length) {
+            ftsSeenKeys.add(docKey);
+            fragmentExpansionDocs.push(rows[0]);
+        }
+    }
     // Tier 2: Token-overlap semantic — always run, scored independently
     const semanticDocs = semanticFallbackDocs(db, `${prompt}\n${keywords}`, detectedProject);
     // Merge with Reciprocal Rank Fusion so documents found by both tiers rank highest
-    const merged = rrfMerge([ftsDocs, semanticDocs]);
+    const merged = rrfMerge([ftsDocs, fragmentExpansionDocs, semanticDocs]);
     if (merged.length === 0)
         return null;
     return merged.slice(0, 12);
@@ -501,6 +515,7 @@ export function applyTrustFilter(rows, ttlDays, minConfidence, decay, phrenPath)
     const queueItems = [];
     const auditEntries = [];
     const highImpactFindingIds = phrenPath ? getHighImpactFindings(phrenPath, 3) : undefined;
+    const impactCounts = phrenPath ? getImpactSurfaceCounts(phrenPath, 1) : undefined;
     const filtered = rows
         .map((doc) => {
         if (!TRUST_FILTERED_TYPES.has(doc.type))
@@ -511,6 +526,7 @@ export function applyTrustFilter(rows, ttlDays, minConfidence, decay, phrenPath)
             decay,
             project: doc.project,
             highImpactFindingIds,
+            impactCounts,
         });
         if (trust.issues.length > 0) {
             const stale = trust.issues.filter((i) => i.reason === "stale").map((i) => i.bullet);
@@ -608,15 +624,13 @@ export function rankResults(rows, intent, gitCtx, detectedProject, phrenPathLoca
         }
     }
     const getRecentDate = (doc) => recentDateCache.get(doc.path || `${doc.project}/${doc.filename}`) ?? "0000-00-00";
-    // Query correlation: pre-warm docs that historically correlated with similar queries
-    const correlatedDocKeys = query ? new Set(getCorrelatedDocs(phrenPathLocal, query, 5)) : new Set();
     // Precompute per-doc ranking metadata once — avoids recomputing inside sort comparator.
     const changedFiles = gitCtx?.changedFiles || new Set();
     const FILE_MATCH_BOOST = 1.5;
     const scored = ranked.map((doc) => {
         const globBoost = getProjectGlobBoost(phrenPathLocal, doc.project, cwd, gitCtx?.changedFiles);
         const key = entryScoreKey(doc.project, doc.filename, doc.content);
-        const entity = entityBoostPaths.has(doc.path) ? 1.3 : 1;
+        const entity = entityBoostPaths.has(doc.path) ? 1.5 : 1;
         const date = getRecentDate(doc);
         const fileRel = fileRelevanceBoost(doc.path, changedFiles);
         const branchMat = branchMatchBoost(doc.content, gitCtx?.branch);
@@ -631,17 +645,19 @@ export function rankResults(rows, intent, gitCtx, detectedProject, phrenPathLoca
             && queryOverlap < WEAK_CROSS_PROJECT_OVERLAP_MAX
             ? WEAK_CROSS_PROJECT_OVERLAP_PENALTY
             : 0;
-        const correlationKey = `${doc.project}/${doc.filename}`;
-        const correlationBoost = correlatedDocKeys.has(correlationKey) ? CORRELATION_BOOST : 0;
+        // Boost skills whose filename matches a query token (e.g. "swarm" matches swarm.md)
+        const skillNameBoost = doc.type === "skill" && queryTokens.length > 0
+            ? queryTokens.some((t) => doc.filename.replace(/\.md$/i, "").toLowerCase() === t) ? 4 : 0
+            : 0;
         const score = Math.round((intentBoost(intent, doc.type) +
+            skillNameBoost +
             fileRel +
             branchMat +
             globBoost +
             qualityMult +
             entity +
             queryOverlap * queryOverlapWeight +
-            recencyBoost(doc.type, date) +
-            correlationBoost -
+            recencyBoost(doc.type, date) -
             weakCrossProjectPenalty -
             lowValuePenalty(doc.content, doc.type)) * crossProjectAgeMultiplier(doc, detectedProject, date) * 10000) / 10000;
         const fileMatch = fileRel > 0 || branchMat > 0;
@@ -706,24 +722,6 @@ export function rankResults(rows, intent, gitCtx, detectedProject, phrenPathLoca
     }
     return ranked;
 }
-/** Annotate snippet lines that carry contradiction metadata with visible markers. */
-export function annotateContradictions(snippet) {
-    return snippet.split('\n').map(line => {
-        const conflictMatch = line.match(/<!-- conflicts_with: "(.*?)" -->/);
-        const contradictMatch = line.match(/<!-- phren:contradicts "(.*?)" -->/);
-        const statusMatch = line.match(/phren:status "contradicted"/);
-        if (conflictMatch) {
-            return line.replace(conflictMatch[0], '') + ` [CONTRADICTED — conflicts with: "${conflictMatch[1]}"]`;
-        }
-        if (contradictMatch) {
-            return line.replace(contradictMatch[0], '') + ` [CONTRADICTED — see: "${contradictMatch[1]}"]`;
-        }
-        if (statusMatch) {
-            return line + ' [CONTRADICTED]';
-        }
-        return line;
-    }).join('\n');
-}
 /** Mark snippet lines with stale citations (cited file missing or line content changed). */
 export function markStaleCitations(snippet) {
     const lines = snippet.split("\n");
@@ -773,10 +771,40 @@ export function markStaleCitations(snippet) {
     }
     return result.join("\n");
 }
+function annotateContradictions(snippet) {
+    return snippet.split('\n').map(line => {
+        const conflictMatch = line.match(/<!-- conflicts_with: "(.*?)" -->/);
+        const contradictMatch = line.match(/<!-- phren:contradicts "(.*?)" -->/);
+        const statusMatch = line.match(/phren:status "contradicted"/);
+        if (conflictMatch) {
+            return line.replace(conflictMatch[0], '') + ` [CONTRADICTED — conflicts with: "${conflictMatch[1]}"]`;
+        }
+        if (contradictMatch) {
+            return line.replace(contradictMatch[0], '') + ` [CONTRADICTED — see: "${contradictMatch[1]}"]`;
+        }
+        if (statusMatch) {
+            return line + ' [CONTRADICTED]';
+        }
+        return line;
+    }).join('\n');
+}
 export function selectSnippets(rows, keywords, tokenBudget, lineBudget, charBudget) {
     const selected = [];
     let usedTokens = 36;
     const queryTokens = tokenizeForOverlap(keywords);
+    const seenBullets = new Set();
+    // For each snippet being added, hash its bullet lines and skip duplicates
+    function dedupSnippetBullets(snippet) {
+        return snippet.split('\n').filter(line => {
+            if (!line.startsWith('- '))
+                return true; // Keep non-bullet lines (headers, etc)
+            const normalized = line.replace(/<!--.*?-->/g, '').trim().toLowerCase();
+            if (seenBullets.has(normalized))
+                return false;
+            seenBullets.add(normalized);
+            return true;
+        }).join('\n');
+    }
     for (const doc of rows) {
         let snippet = compactSnippet(extractSnippet(doc.content, keywords, 8), lineBudget, charBudget);
         if (!snippet.trim())
@@ -785,8 +813,10 @@ export function selectSnippets(rows, keywords, tokenBudget, lineBudget, charBudg
         if (TRUST_FILTERED_TYPES.has(doc.type)) {
             snippet = markStaleCitations(snippet);
         }
-        // Surface contradiction metadata as visible annotations
         snippet = annotateContradictions(snippet);
+        snippet = dedupSnippetBullets(snippet);
+        if (!snippet.trim())
+            continue;
         let focusScore = queryTokens.length > 0
             ? overlapScore(queryTokens, `${doc.filename}\n${snippet}`)
             : 1;

package/mcp/dist/test-global-setup.js

@@ -1,10 +1,9 @@
 /**
  * Vitest globalSetup — runs once in the main process before any test workers spawn.
  *
- * Builds mcp/dist if it is missing or stale so every fork sees a complete,
- * consistent dist artifact. Running the build here (rather than inside each
- * fork via ensureCliBuilt) eliminates the race condition where one fork runs
- * `rm -rf mcp/dist` while another fork is checking fs.existsSync(CLI_PATH).
+ * Builds mcp/dist if it is missing so every fork sees a complete, consistent
+ * dist artifact before tests begin. Individual subprocess helpers can still
+ * repair a missing artifact later under a lock if some test mutates dist.
  *
  * `pretest` in package.json already calls `npm run build`, so in normal `npm test`
  * runs this is a fast no-op check. It is the safety net for:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phren/cli",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Knowledge layer for AI agents. Claude remembers you. Phren remembers your work.",
   "type": "module",
   "bin": {
@@ -34,7 +34,7 @@
     "vitest": "^4.0.18"
   },
   "scripts": {
-    "build": "rm -rf mcp/dist && tsc -p mcp/tsconfig.json && chmod +x mcp/dist/index.js && cp mcp/src/synonyms*.json mcp/dist/",
+    "build": "node scripts/build.mjs",
     "dev": "tsx mcp/src/index.ts",
     "lint": "eslint mcp/src/ --ignore-pattern '*.test.ts'",
     "validate-docs": "bash scripts/validate-docs.sh",