@phren/cli 0.0.9 → 0.0.11

package/mcp/dist/cli-govern.js

@@ -144,7 +144,7 @@ export async function handlePruneMemories(args = []) {
                 .filter((e) => e !== null);
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            if ((process.env.PHREN_DEBUG))
                 process.stderr.write(`[phren] cli-govern retrievalLog readParse: ${errorMessage(err)}\n`);
         }
     }
@@ -227,6 +227,139 @@ export async function handleConsolidateMemories(args = []) {
         return;
     console.log(`Updated backups (${backups.length}): ${backups.join(", ")}`);
 }
+export async function handleGcMaintain(args = []) {
+    const dryRun = args.includes("--dry-run");
+    const phrenPath = getPhrenPath();
+    const { execSync } = await import("child_process");
+    const report = {
+        gitGcRan: false,
+        commitsSquashed: 0,
+        sessionsRemoved: 0,
+        runtimeLogsRemoved: 0,
+    };
+    // 1. Run git gc --aggressive on the ~/.phren repo
+    if (dryRun) {
+        console.log("[dry-run] Would run: git gc --aggressive");
+    }
+    else {
+        try {
+            execSync("git gc --aggressive --quiet", { cwd: phrenPath, stdio: "pipe" });
+            report.gitGcRan = true;
+            console.log("git gc --aggressive: done");
+        }
+        catch (err) {
+            console.error(`git gc failed: ${errorMessage(err)}`);
+        }
+    }
+    // 2. Squash old auto-save commits (older than 7 days) into weekly summaries
+    const sevenDaysAgo = new Date(Date.now() - 7 * 86400000).toISOString().slice(0, 10);
+    let oldCommits = [];
+    try {
+        const raw = execSync(`git log --before="${sevenDaysAgo}" --format="%H %ci %s"`, { cwd: phrenPath, encoding: "utf8" }).trim();
+        if (raw) {
+            oldCommits = raw.split("\n").filter((l) => l.includes("auto-save:") || l.includes("[auto]"));
+        }
+    }
+    catch {
+        // Not a git repo or no commits — skip silently
+    }
+    if (oldCommits.length === 0) {
+        console.log("Commit squash: no old auto-save commits to squash.");
+    }
+    else if (dryRun) {
+        console.log(`[dry-run] Would squash ${oldCommits.length} auto-save commits older than 7 days into weekly summaries.`);
+        report.commitsSquashed = oldCommits.length;
+    }
+    else {
+        // Group by ISO week based on commit timestamp (already in the log output)
+        const commitsByWeek = new Map();
+        for (const line of oldCommits) {
+            const hash = line.split(" ")[0];
+            // Format: "HASH YYYY-MM-DD HH:MM:SS +ZZZZ subject..."
+            const dateMatch = line.match(/^[a-f0-9]+ (\d{4}-\d{2}-\d{2})/);
+            if (!dateMatch)
+                continue;
+            const date = new Date(dateMatch[1]);
+            const weekStart = new Date(date);
+            weekStart.setDate(date.getDate() - date.getDay());
+            const weekKey = weekStart.toISOString().slice(0, 10);
+            if (!commitsByWeek.has(weekKey))
+                commitsByWeek.set(weekKey, []);
+            commitsByWeek.get(weekKey).push(hash);
+        }
+        // For each week with multiple commits, soft-reset to oldest and amend into a summary
+        for (const [weekKey, hashes] of commitsByWeek.entries()) {
+            if (hashes.length < 2)
+                continue;
+            try {
+                const oldest = hashes[hashes.length - 1];
+                const newest = hashes[0];
+                // Use git rebase --onto to squash: squash all into the oldest parent
+                const parentOfOldest = execSync(`git rev-parse ${oldest}^`, { cwd: phrenPath, encoding: "utf8" }).trim();
+                // Build rebase script via env variable to squash all but first to "squash"
+                const rebaseScript = hashes
+                    .map((h, i) => `${i === hashes.length - 1 ? "pick" : "squash"} ${h} auto-save`)
+                    .reverse()
+                    .join("\n");
+                const scriptPath = path.join(phrenPath, ".runtime", `gc-rebase-${weekKey}.sh`);
+                fs.writeFileSync(scriptPath, rebaseScript);
+                // Use GIT_SEQUENCE_EDITOR to feed our script
+                execSync(`GIT_SEQUENCE_EDITOR="cat ${scriptPath} >" git rebase -i ${parentOfOldest}`, { cwd: phrenPath, stdio: "pipe" });
+                fs.unlinkSync(scriptPath);
+                report.commitsSquashed += hashes.length - 1;
+                console.log(`Squashed ${hashes.length} auto-save commits for week of ${weekKey} (${newest.slice(0, 7)}..${oldest.slice(0, 7)}).`);
+            }
+            catch {
+                // Squashing is best-effort — log and continue
+                console.warn(`  Could not squash auto-save commits for week ${weekKey} (possibly non-linear history). Skipping.`);
+            }
+        }
+        if (report.commitsSquashed === 0) {
+            console.log("Commit squash: all old auto-save weeks have only one commit, nothing to squash.");
+        }
+    }
+    // 3–4. Prune stale files from .sessions/ and .runtime/
+    const thirtyDaysAgo = Date.now() - 30 * 86400000;
+    function pruneStaleFiles(dir, label, filter) {
+        let removed = 0;
+        if (!fs.existsSync(dir))
+            return removed;
+        for (const entry of fs.readdirSync(dir)) {
+            if (filter && !filter(entry))
+                continue;
+            const fullPath = path.join(dir, entry);
+            try {
+                if (fs.statSync(fullPath).mtimeMs < thirtyDaysAgo) {
+                    if (dryRun) {
+                        console.log(`[dry-run] Would remove: ${label}/${entry}`);
+                    }
+                    else {
+                        fs.unlinkSync(fullPath);
+                    }
+                    removed++;
+                }
+            }
+            catch { /* skip unreadable */ }
+        }
+        return removed;
+    }
+    const logExtensions = new Set([".log", ".jsonl", ".json"]);
+    const protectedFiles = new Set(["audit.log", "telemetry.json"]);
+    report.sessionsRemoved = pruneStaleFiles(path.join(phrenPath, ".sessions"), ".sessions");
+    report.runtimeLogsRemoved = pruneStaleFiles(path.join(phrenPath, ".runtime"), ".runtime", (entry) => logExtensions.has(path.extname(entry)) && !protectedFiles.has(entry));
+    const verb = dryRun ? "Would remove" : "Removed";
+    console.log(`${verb} ${report.sessionsRemoved} stale session marker(s) from .sessions/`);
+    console.log(`${verb} ${report.runtimeLogsRemoved} stale runtime log(s) from .runtime/`);
+    // 5. Summary
+    if (!dryRun) {
+        appendAuditLog(phrenPath, "maintain_gc", `gitGc=${report.gitGcRan} squashed=${report.commitsSquashed} sessions=${report.sessionsRemoved} logs=${report.runtimeLogsRemoved}`);
+    }
+    console.log(`\nGC complete:${dryRun ? " (dry-run)" : ""}` +
+        ` git_gc=${report.gitGcRan}` +
+        ` commits_squashed=${report.commitsSquashed}` +
+        ` sessions_pruned=${report.sessionsRemoved}` +
+        ` logs_pruned=${report.runtimeLogsRemoved}`);
+}
 // ── Maintain router ──────────────────────────────────────────────────────────
 export async function handleMaintain(args) {
     const sub = args[0];
@@ -245,6 +378,8 @@ export async function handleMaintain(args) {
             return handleExtractMemories(rest[0]);
         case "restore":
             return handleRestoreBackup(rest);
+        case "gc":
+            return handleGcMaintain(rest);
         default:
             console.log(`phren maintain - memory maintenance and governance
 
@@ -258,7 +393,9 @@ Subcommands:
                                          Deduplicate FINDINGS.md bullets. Run after a burst of work
                                          when findings feel repetitive, or monthly to keep things clean.
   phren maintain extract [project]      Mine git/GitHub signals into memory candidates
-  phren maintain restore [project]      List and restore from .bak files`);
+  phren maintain restore [project]      List and restore from .bak files
+  phren maintain gc [--dry-run]         Garbage-collect the ~/.phren repo: git gc, squash old
+                                         auto-save commits, prune stale session markers and runtime logs`);
             if (sub) {
                 console.error(`\nUnknown maintain subcommand: "${sub}"`);
                 process.exit(1);
@@ -364,7 +501,7 @@ export async function handleBackgroundMaintenance(projectArg) {
             fs.unlinkSync(markers.lock);
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            if ((process.env.PHREN_DEBUG))
                 process.stderr.write(`[phren] cli-govern backgroundMaintenance unlockFinal: ${errorMessage(err)}\n`);
         }
     }

package/mcp/dist/cli-graph.js

@@ -1,6 +1,7 @@
 import { getPhrenPath } from "./shared.js";
 import { buildIndex, queryRows } from "./shared-index.js";
 import { resolveRuntimeProfile } from "./runtime-profile.js";
+import { errorMessage } from "./utils.js";
 /**
  * CLI: phren graph [--project <name>] [--limit <n>]
  * Displays the fragment knowledge graph as a table.
@@ -115,7 +116,7 @@ export async function handleGraphLink(args) {
         db.run("INSERT OR IGNORE INTO entity_links (source_id, target_id, rel_type, source_doc) VALUES (?, ?, ?, ?)", [sourceId, targetId, "mentions", sourceDoc]);
     }
     catch (err) {
-        console.error(`Failed to link: ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`Failed to link: ${errorMessage(err)}`);
         process.exit(1);
     }
     // Persist to manual-links.json
@@ -144,7 +145,7 @@ export async function handleGraphLink(args) {
         });
     }
     catch (err) {
-        console.error(`Failed to persist manual link: ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`Failed to persist manual link: ${errorMessage(err)}`);
         process.exit(1);
     }
     console.log(`Linked "${fragmentName}" to ${sourceDoc}.`);

package/mcp/dist/cli-hooks-globs.js

@@ -1,6 +1,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import { capCache } from "./shared.js";
+import { errorMessage } from "./utils.js";
 // ── Glob matching and project frontmatter ────────────────────────────────────
 const projectGlobCache = new Map();
 export function clearProjectGlobCache() {
@@ -45,7 +46,7 @@ function parseProjectGlobs(phrenPathLocal, project) {
     }
     catch (err) {
         if (process.env.PHREN_DEBUG)
-            process.stderr.write(`[phren] getProjectGlobs: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.stderr.write(`[phren] getProjectGlobs: ${errorMessage(err)}\n`);
     }
     projectGlobCache.set(project, globs);
     capCache(projectGlobCache);

package/mcp/dist/cli-hooks-output.js

@@ -1,7 +1,7 @@
 import { recordInjection, recordRetrieval, } from "./shared-governance.js";
 import { getDocSourceKey, } from "./shared-index.js";
 import { logImpact, extractFindingIdsFromSnippet, } from "./finding-impact.js";
-import { isFeatureEnabled } from "./utils.js";
+import { isFeatureEnabled, errorMessage } from "./utils.js";
 import { annotateStale } from "./cli-hooks-citations.js";
 import { approximateTokens, fileRelevanceBoost, branchMatchBoost } from "./shared-retrieval.js";
 // ── Progressive disclosure helpers ────────────────────────────────────────────
@@ -56,7 +56,7 @@ export function buildHookOutput(selected, usedTokens, intent, gitCtx, detectedPr
             }
             catch (err) {
                 if (process.env.PHREN_DEBUG)
-                    process.stderr.write(`[phren] injectContext recordRetrieval: ${err instanceof Error ? err.message : String(err)}\n`);
+                    process.stderr.write(`[phren] injectContext recordRetrieval: ${errorMessage(err)}\n`);
             }
         }
     }
@@ -108,7 +108,7 @@ export function buildHookOutput(selected, usedTokens, intent, gitCtx, detectedPr
             }
             catch (err) {
                 if (process.env.PHREN_DEBUG)
-                    process.stderr.write(`[phren] injectContext recordRetrievalOrdered: ${err instanceof Error ? err.message : String(err)}\n`);
+                    process.stderr.write(`[phren] injectContext recordRetrievalOrdered: ${errorMessage(err)}\n`);
             }
             parts.push(`[${getDocSourceKey(doc, phrenPathLocal)}] (${doc.type})`);
             parts.push(annotateStale(snippet));

package/mcp/dist/cli-hooks.js

@@ -5,7 +5,7 @@
 //   cli-hooks-output.ts     — hook output formatting
 //   cli-hooks-globs.ts      — project glob matching
 import { debugLog, sessionMarker, sessionsDir, getPhrenPath, } from "./shared.js";
-import { getRetentionPolicy, getWorkflowPolicy, } from "./shared-governance.js";
+import { mergeConfig, } from "./shared-governance.js";
 import { buildIndex, detectProject, } from "./shared-index.js";
 import { isProjectHookEnabled } from "./project-config.js";
 import { checkConsolidationNeeded, } from "./shared-content.js";
@@ -126,7 +126,7 @@ export async function handleHookPrompt() {
     }
     catch (err) {
         if (process.env.PHREN_DEBUG)
-            process.stderr.write(`[phren] hookPrompt stdinRead: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.stderr.write(`[phren] hookPrompt stdinRead: ${errorMessage(err)}\n`);
         process.exit(0);
     }
     const input = parseHookInput(raw);
@@ -182,6 +182,7 @@ export async function handleHookPrompt() {
         appendAuditLog(getPhrenPath(), "hook_prompt", `status=project_disabled project=${detectedProject}`);
         process.exit(0);
     }
+    const resolvedConfig = mergeConfig(getPhrenPath(), detectedProject ?? undefined);
     const safeQuery = buildRobustFtsQuery(keywords, detectedProject, getPhrenPath());
     if (!safeQuery)
         process.exit(0);
@@ -193,14 +194,17 @@ export async function handleHookPrompt() {
             process.exit(0);
         autoLearnQuerySynonyms(getPhrenPath(), detectedProject, keywordEntries, rows);
         const tTrust0 = Date.now();
-        const policy = getRetentionPolicy(getPhrenPath());
+        const policy = resolvedConfig.retentionPolicy;
         const memoryTtlDays = Number.parseInt(process.env.PHREN_MEMORY_TTL_DAYS || String(policy.ttlDays), 10);
         const trustResult = applyTrustFilter(rows, Number.isNaN(memoryTtlDays) ? policy.ttlDays : memoryTtlDays, policy.minInjectConfidence, policy.decay, getPhrenPath());
         rows = trustResult.rows;
         stage.trustMs = Date.now() - tTrust0;
         if (!rows.length)
             process.exit(0);
-        if (isFeatureEnabled("PHREN_FEATURE_AUTO_EXTRACT", true) && getProactivityLevelForFindings(getPhrenPath()) !== "low" && sessionId && detectedProject && cwd) {
+        const findingsProactivity = resolvedConfig.proactivity.findings
+            ?? resolvedConfig.proactivity.base
+            ?? getProactivityLevelForFindings(getPhrenPath());
+        if (isFeatureEnabled("PHREN_FEATURE_AUTO_EXTRACT", true) && findingsProactivity !== "low" && sessionId && detectedProject && cwd) {
             const marker = sessionMarker(getPhrenPath(), `extracted-${sessionId}-${detectedProject}`);
             if (!fs.existsSync(marker)) {
                 try {
@@ -260,7 +264,9 @@ export async function handleHookPrompt() {
             debugLog(`injection-budget: trimmed ${selected.length} -> ${kept.length} snippets to fit ${maxInjectTokens} token budget`);
         }
         const parts = buildHookOutput(budgetSelected, budgetUsedTokens, intent, gitCtx, detectedProject, stage, safeTokenBudget, getPhrenPath(), sessionId);
-        const taskLevel = getProactivityLevelForTask(getPhrenPath());
+        const taskLevel = resolvedConfig.proactivity.tasks
+            ?? resolvedConfig.proactivity.base
+            ?? getProactivityLevelForTask(getPhrenPath());
         const taskLifecycle = handleTaskPromptLifecycle({
             phrenPath: getPhrenPath(),
             prompt,
@@ -275,8 +281,7 @@ export async function handleHookPrompt() {
         }
         // Inject finding sensitivity agent instruction
         try {
-            const workflowPolicy = getWorkflowPolicy(getPhrenPath());
-            const sensitivity = workflowPolicy.findingSensitivity ?? "balanced";
+            const sensitivity = resolvedConfig.findingSensitivity ?? "balanced";
             const sensitivityConfig = FINDING_SENSITIVITY_CONFIG[sensitivity];
             if (sensitivityConfig) {
                 parts.push("");
@@ -304,36 +309,38 @@ export async function handleHookPrompt() {
         const noticeFile = sessionId ? sessionMarker(getPhrenPath(), `noticed-${sessionId}`) : null;
         const alreadyNoticed = noticeFile ? fs.existsSync(noticeFile) : false;
         if (!alreadyNoticed) {
-            // Clean up stale session markers (>24h old) from .sessions/ dir
-            try {
-                const cutoff = Date.now() - 86400000;
-                const sessDir = sessionsDir(getPhrenPath());
-                if (fs.existsSync(sessDir)) {
-                    for (const f of fs.readdirSync(sessDir)) {
-                        if (!f.startsWith("noticed-") && !f.startsWith("extracted-"))
+            // Defer stale session marker cleanup to after output — it's I/O-heavy and not needed for results
+            setImmediate(() => {
+                try {
+                    const cutoff = Date.now() - 86400000;
+                    const sessDir = sessionsDir(getPhrenPath());
+                    if (fs.existsSync(sessDir)) {
+                        for (const f of fs.readdirSync(sessDir)) {
+                            if (!f.startsWith("noticed-") && !f.startsWith("extracted-"))
+                                continue;
+                            const fp = `${sessDir}/${f}`;
+                            try {
+                                if (fs.statSync(fp).mtimeMs < cutoff)
+                                    fs.unlinkSync(fp);
+                            }
+                            catch { /* ignore per-file errors */ }
+                        }
+                    }
+                    // Also clean stale markers from the phren root
+                    for (const f of fs.readdirSync(getPhrenPath())) {
+                        if (!f.startsWith(".noticed-") && !f.startsWith(".extracted-"))
                             continue;
-                        const fp = `${sessDir}/${f}`;
-                        if (fs.statSync(fp).mtimeMs < cutoff)
+                        const fp = `${getPhrenPath()}/${f}`;
+                        try {
                             fs.unlinkSync(fp);
+                        }
+                        catch { /* ignore */ }
                     }
                 }
-                // Also clean stale markers from the phren root
-                for (const f of fs.readdirSync(getPhrenPath())) {
-                    if (!f.startsWith(".noticed-") && !f.startsWith(".extracted-"))
-                        continue;
-                    const fp = `${getPhrenPath()}/${f}`;
-                    try {
-                        fs.unlinkSync(fp);
-                    }
-                    catch (err) {
-                        if (process.env.PHREN_DEBUG)
-                            process.stderr.write(`[phren] hookPrompt staleNoticeUnlink: ${errorMessage(err)}\n`);
-                    }
+                catch (err) {
+                    debugLog(`stale notice cleanup failed: ${errorMessage(err)}`);
                 }
-            }
-            catch (err) {
-                debugLog(`stale notice cleanup failed: ${errorMessage(err)}`);
-            }
+            });
             const needed = checkConsolidationNeeded(getPhrenPath(), profile);
             if (needed.length > 0) {
                 const notices = needed.map((n) => {
@@ -345,7 +352,7 @@ export async function handleHookPrompt() {
                 parts.push(`Findings ready for consolidation:`);
                 parts.push(notices.join("\n"));
                 parts.push(`Run phren-consolidate when ready.`);
-                parts.push(`</phren-notice>`);
+                parts.push(`<phren-notice>`);
             }
             if (noticeFile) {
                 try {
@@ -367,7 +374,7 @@ export async function handleHookPrompt() {
     }
     catch (err) {
         const msg = errorMessage(err);
-        process.stdout.write(`\n<phren-error>phren hook failed: ${msg}. Check ~/.phren/.runtime/debug.log for details.</phren-error>\n`);
+        process.stdout.write(`\n<phren-error>phren hook failed: ${msg}. Check ~/.phren/.runtime/debug.log for details.<phren-error>\n`);
         debugLog(`hook-prompt error: ${msg}`);
         process.exit(0);
     }

package/mcp/dist/cli-namespaces.js

@@ -5,6 +5,7 @@ import { expandHomePath, findProjectNameCaseInsensitive, getPhrenPath, getProjec
 import { isValidProjectName, errorMessage } from "./utils.js";
 import { readInstallPreferences, writeInstallPreferences } from "./init-preferences.js";
 import { buildSkillManifest, findLocalSkill, findSkill, getAllSkills } from "./skill-registry.js";
+import { detectSkillCollisions } from "./link-skills.js";
 import { setSkillEnabledAndSync, syncSkillLinksForScope } from "./skill-files.js";
 import { findProjectDir } from "./project-locator.js";
 import { TASK_FILE_ALIASES, addTask, completeTask, updateTask, reorderTask, pinTask, removeTask, workNextTask, tidyDoneTasks, linkTaskIssue, promoteTask, resolveTaskItem } from "./data-tasks.js";
@@ -76,7 +77,7 @@ function openInEditor(filePath) {
         execFileSync(editor, [filePath], { stdio: "inherit" });
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] openInEditor: ${errorMessage(err)}\n`);
         console.error(`Editor "${editor}" failed. Set $EDITOR to your preferred editor.`);
         process.exit(1);
@@ -145,7 +146,7 @@ export function handleSkillsNamespace(args, profile) {
             console.log(`Linked skill ${fileName} into ${project}.`);
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            if ((process.env.PHREN_DEBUG))
                 process.stderr.write(`[phren] skill add symlinkFailed: ${errorMessage(err)}\n`);
             fs.copyFileSync(source, dest);
             console.log(`Copied skill ${fileName} into ${project}.`);
@@ -450,7 +451,7 @@ export function handleDetectSkills(args, profile) {
                 continue;
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            if ((process.env.PHREN_DEBUG))
                 process.stderr.write(`[phren] skillList lstat: ${errorMessage(err)}\n`);
         }
         const name = entry.replace(/\.md$/, "");
@@ -548,6 +549,15 @@ function printSkillDoctor(scope, manifest, destDir) {
                 problems.push(`Mirror drift for ${skill.name}: expected ${dest} -> ${skill.root}`);
             }
         }
+        // Check for user-owned files blocking phren skill links
+        const phrenPath = getPhrenPath();
+        const srcDir = scope.toLowerCase() === "global"
+            ? path.join(phrenPath, "global", "skills")
+            : path.join(phrenPath, scope, "skills");
+        const collisions = detectSkillCollisions(srcDir, destDir, phrenPath);
+        for (const collision of collisions) {
+            problems.push(`Skill collision: ${collision.message}`);
+        }
     }
     if (!manifest.problems.length && !problems.length) {
         console.log("\nDoctor: no skill pipeline issues detected.");
@@ -853,7 +863,7 @@ function handleProjectsList(profile) {
             dirFiles = new Set(fs.readdirSync(projectDir));
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            if ((process.env.PHREN_DEBUG))
                 process.stderr.write(`[phren] projects list readdir: ${errorMessage(err)}\n`);
             dirFiles = new Set();
         }
@@ -896,7 +906,7 @@ async function handleProjectsRemove(name, profile) {
         countFiles(projectDir);
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] projects remove countFiles: ${errorMessage(err)}\n`);
     }
     const readline = await import("readline");

package/mcp/dist/cli-search.js

@@ -34,7 +34,7 @@ export function readSearchHistory(phrenPath) {
             .map((line) => JSON.parse(line));
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] readSearchHistory: ${errorMessage(err)}\n`);
         return [];
     }
@@ -253,7 +253,7 @@ export async function runSearch(opts, phrenPath, profile) {
                     logSearchMiss(phrenPath, opts.query, opts.project);
                 }
                 catch (err) {
-                    if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                    if ((process.env.PHREN_DEBUG))
                         process.stderr.write(`[phren] search logSearchMiss: ${errorMessage(err)}\n`);
                 }
             }

package/mcp/dist/content-archive.js

@@ -107,7 +107,7 @@ function isAlreadyArchived(referenceDir, bullet) {
         }
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] isDuplicateInReference: ${errorMessage(err)}\n`);
     }
     return false;
@@ -271,7 +271,7 @@ export function autoArchiveToReference(phrenPath, project, keepCount) {
             fs.unlinkSync(lockFile);
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            if ((process.env.PHREN_DEBUG))
                 process.stderr.write(`[phren] autoArchiveToReference unlockFile: ${errorMessage(err)}\n`);
         }
     }

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, parseFindingLifecycle } from "./finding-lifecycle.js";
+import { FINDING_TYPE_DECAY, extractFindingType } from "./finding-lifecycle.js";
 export const FINDING_PROVENANCE_SOURCES = [
     "human",
     "agent",
@@ -294,7 +294,6 @@ 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 = [];
@@ -413,29 +412,20 @@ export function filterTrustedFindingsDetailed(content, opts) {
             confidence *= 0.9;
         if (project && highImpactFindingIds?.size) {
             const findingId = findingIdFromLine(line);
-            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));
-                    }
+            if (highImpactFindingIds.has(findingId))
+                confidence *= 1.15;
+        }
+        // Confirmed findings decay 3x slower — recompute confidence with reduced age
+        {
+            const findingId = findingIdFromLine(line);
+            if (findingId && highImpactFindingIds?.has(findingId) && 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-dedup.js

@@ -2,7 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as crypto from "crypto";
 import { debugLog, runtimeFile, KNOWN_OBSERVATION_TAGS } from "./shared.js";
-import { isFeatureEnabled, safeProjectPath } from "./utils.js";
+import { isFeatureEnabled, safeProjectPath, errorMessage } from "./utils.js";
 import { UNIVERSAL_TECH_TERMS_RE, EXTRA_ENTITY_PATTERNS } from "./phren-core.js";
 import { isInactiveFindingLine } from "./finding-lifecycle.js";
 // ── LLM provider abstraction ────────────────────────────────────────────────
@@ -50,8 +50,8 @@ async function withCache(cachePath, key, ttlMs, compute) {
         }
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-            process.stderr.write(`[phren] withCache load (${path.basename(cachePath)}): ${err instanceof Error ? err.message : String(err)}\n`);
+        if ((process.env.PHREN_DEBUG))
+            process.stderr.write(`[phren] withCache load (${path.basename(cachePath)}): ${errorMessage(err)}\n`);
     }
     const result = await compute();
     // Persist result
@@ -61,8 +61,8 @@ async function withCache(cachePath, key, ttlMs, compute) {
         persistCache(cachePath, cache);
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-            process.stderr.write(`[phren] withCache persist (${path.basename(cachePath)}): ${err instanceof Error ? err.message : String(err)}\n`);
+        if ((process.env.PHREN_DEBUG))
+            process.stderr.write(`[phren] withCache persist (${path.basename(cachePath)}): ${errorMessage(err)}\n`);
     }
     return result;
 }
@@ -562,8 +562,8 @@ export async function checkSemanticConflicts(phrenPath, project, newFinding, sig
                 return { name: e.name, mtime: fs.statSync(fp).mtimeMs, fp };
             }
             catch (err) {
-                if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-                    process.stderr.write(`[phren] crossProjectScan stat: ${err instanceof Error ? err.message : String(err)}\n`);
+                if ((process.env.PHREN_DEBUG))
+                    process.stderr.write(`[phren] crossProjectScan stat: ${errorMessage(err)}\n`);
                 return null;
             }
         })
@@ -577,8 +577,8 @@ export async function checkSemanticConflicts(phrenPath, project, newFinding, sig
         }
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-            process.stderr.write(`[phren] crossProjectScan: ${err instanceof Error ? err.message : String(err)}\n`);
+        if ((process.env.PHREN_DEBUG))
+            process.stderr.write(`[phren] crossProjectScan: ${errorMessage(err)}\n`);
     }
     const annotations = [];
     const deadline = Date.now() + CONFLICT_CHECK_TOTAL_TIMEOUT_MS;

package/mcp/dist/data-access.js

@@ -8,7 +8,7 @@ import { isValidProjectName, queueFilePath, safeProjectPath, errorMessage } from
 import { parseCitationComment, parseSourceComment, } from "./content-citation.js";
 import { parseFindingLifecycle, } from "./finding-lifecycle.js";
 import { METADATA_REGEX, isCitationLine, isArchiveStart, isArchiveEnd, parseFindingId, parseAllContradictions, stripComments, } from "./content-metadata.js";
-export { readTasks, readTasksAcrossProjects, resolveTaskItem, addTask, addTasks, completeTasks, completeTask, removeTask, updateTask, linkTaskIssue, pinTask, unpinTask, workNextTask, tidyDoneTasks, taskMarkdown, appendChildFinding, promoteTask, TASKS_FILENAME, TASK_FILE_ALIASES, canonicalTaskFilePath, resolveTaskFilePath, isTaskFileName, } from "./data-tasks.js";
+export { readTasks, readTasksAcrossProjects, resolveTaskItem, addTask, addTasks, completeTasks, completeTask, removeTask, removeTasks, updateTask, linkTaskIssue, pinTask, unpinTask, workNextTask, tidyDoneTasks, taskMarkdown, appendChildFinding, promoteTask, TASKS_FILENAME, TASK_FILE_ALIASES, canonicalTaskFilePath, resolveTaskFilePath, isTaskFileName, } from "./data-tasks.js";
 export { addProjectToProfile, listMachines, listProfiles, listProjectCards, removeProjectFromProfile, setMachineProfile, } from "./profile-store.js";
 export { loadShellState, readRuntimeHealth, resetShellState, saveShellState, } from "./shell-state-store.js";
 function withSafeLock(filePath, fn) {

package/mcp/dist/data-tasks.js

@@ -528,6 +528,29 @@ export function removeTask(phrenPath, project, match) {
         return phrenOk(`Removed task from ${project}: ${item.line}`);
     });
 }
+export function removeTasks(phrenPath, project, matches) {
+    const bPath = canonicalTaskFilePath(phrenPath, project);
+    if (!bPath)
+        return phrenErr(`Project name "${project}" is not valid.`, PhrenError.INVALID_PROJECT_NAME);
+    return withSafeLock(bPath, () => {
+        const parsed = readTasks(phrenPath, project);
+        if (!parsed.ok)
+            return forwardErr(parsed);
+        const removed = [];
+        const errors = [];
+        for (const match of matches) {
+            const found = findItemByMatch(parsed.data, match);
+            if (found.error || !found.match) {
+                errors.push(match);
+                continue;
+            }
+            const [item] = parsed.data.items[found.match.section].splice(found.match.index, 1);
+            removed.push(item.line);
+        }
+        writeTaskDoc(parsed.data);
+        return phrenOk({ removed, errors });
+    });
+}
 export function updateTask(phrenPath, project, match, updates) {
     const bPath = canonicalTaskFilePath(phrenPath, project);
     if (!bPath)