@phren/cli 0.0.9 → 0.0.11

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

@@ -12,7 +12,8 @@ import { readInstallPreferences, writeInstallPreferences, writeGovernanceInstall
 import { buildGraph, collectProjectsForUI, collectSkillsForUI, getHooksData, isAllowedFilePath, readSyncSnapshot, recentAccepted, recentUsage, } from "./memory-ui-data.js";
 import { CONSOLIDATION_ENTRY_THRESHOLD } from "./content-validate.js";
 import { ensureTopicReferenceDoc, getProjectTopicsResponse, listProjectReferenceDocs, pinProjectTopicSuggestion, readReferenceContent, reclassifyLegacyTopicDocs, unpinProjectTopicSuggestion, writeProjectTopics, } from "./project-topics.js";
-import { getWorkflowPolicy, updateWorkflowPolicy } from "./governance-policy.js";
+import { getWorkflowPolicy, updateWorkflowPolicy, mergeConfig, getRetentionPolicy, getProjectConfigOverrides } from "./governance-policy.js";
+import { updateProjectConfigOverrides } from "./project-config.js";
 import { findSkill } from "./skill-registry.js";
 import { setSkillEnabledAndSync } from "./skill-files.js";
 import { listAllSessions, getSessionArtifacts } from "./mcp-session.js";
@@ -290,7 +291,7 @@ export function createWebUiHttpServer(phrenPath, renderPage, profile, opts) {
         repairPreexistingInstall(phrenPath);
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] web-ui repair: ${errorMessage(err)}\n`);
     }
     const authToken = opts?.authToken;
@@ -365,7 +366,7 @@ export function createWebUiHttpServer(phrenPath, renderPage, profile, opts) {
                 }
                 catch (err) {
                     res.writeHead(200, { "content-type": "application/json" });
-                    res.end(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+                    res.end(JSON.stringify({ ok: false, error: errorMessage(err) }));
                 }
             });
             return;
@@ -856,8 +857,13 @@ export function createWebUiHttpServer(phrenPath, renderPage, profile, opts) {
             try {
                 const prefs = readInstallPreferences(phrenPath);
                 const workflowPolicy = getWorkflowPolicy(phrenPath);
+                const retentionPolicy = getRetentionPolicy(phrenPath);
                 const hooksData = getHooksData(phrenPath);
                 const proactivityFindings = prefs.proactivityFindings || prefs.proactivity || "high";
+                const qs = url.includes("?") ? querystring.parse(url.slice(url.indexOf("?") + 1)) : {};
+                const settingsProject = String(qs.project || "");
+                const merged = settingsProject && isValidProjectName(settingsProject) ? mergeConfig(phrenPath, settingsProject) : null;
+                const overrides = settingsProject && isValidProjectName(settingsProject) ? getProjectConfigOverrides(phrenPath, settingsProject) : null;
                 res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
                 res.end(JSON.stringify({
                     ok: true,
@@ -871,6 +877,10 @@ export function createWebUiHttpServer(phrenPath, renderPage, profile, opts) {
                     hooksEnabled: hooksData.globalEnabled,
                     mcpEnabled: prefs.mcpEnabled !== false,
                     hookTools: hooksData.tools,
+                    retentionPolicy,
+                    workflowPolicy,
+                    merged,
+                    overrides,
                 }));
             }
             catch (err) {
@@ -975,6 +985,108 @@ export function createWebUiHttpServer(phrenPath, renderPage, profile, opts) {
             });
             return;
         }
+        // POST /api/settings/project-overrides — write per-project config overrides
+        if (req.method === "POST" && pathname === "/api/settings/project-overrides") {
+            void readFormBody(req, res).then((parsed) => {
+                if (!parsed)
+                    return;
+                if (!requirePostAuth(req, res, url, parsed, authToken, true))
+                    return;
+                if (!requireCsrf(res, parsed, csrfTokens, true))
+                    return;
+                const project = String(parsed.project || "");
+                const field = String(parsed.field || "");
+                const value = String(parsed.value || "");
+                const clearField = String(parsed.clear || "") === "true";
+                if (!project || !isValidProjectName(project)) {
+                    res.writeHead(400, { "content-type": "application/json" });
+                    res.end(JSON.stringify({ ok: false, error: "Invalid project name" }));
+                    return;
+                }
+                const registeredProjects = getProjectDirs(phrenPath, profile).map((d) => path.basename(d)).filter((p) => p !== "global");
+                const isRegistered = registeredProjects.includes(project);
+                const registrationWarning = isRegistered ? undefined : `Project '${project}' is not registered in the active profile. Config was saved but it will have no effect until the project is added with 'phren add'.`;
+                const VALID_FIELDS = {
+                    findingSensitivity: ["minimal", "conservative", "balanced", "aggressive"],
+                    proactivity: ["high", "medium", "low"],
+                    proactivityFindings: ["high", "medium", "low"],
+                    proactivityTask: ["high", "medium", "low"],
+                    taskMode: ["off", "manual", "suggest", "auto"],
+                };
+                const NUMERIC_RETENTION_FIELDS = ["ttlDays", "retentionDays", "autoAcceptThreshold", "minInjectConfidence"];
+                const NUMERIC_WORKFLOW_FIELDS = ["lowConfidenceThreshold"];
+                try {
+                    updateProjectConfigOverrides(phrenPath, project, (current) => {
+                        const next = { ...current };
+                        if (clearField) {
+                            if (field in VALID_FIELDS)
+                                delete next[field];
+                            else if (NUMERIC_RETENTION_FIELDS.includes(field)) {
+                                if (next.retentionPolicy)
+                                    delete next.retentionPolicy[field];
+                            }
+                            else if (NUMERIC_WORKFLOW_FIELDS.includes(field)) {
+                                if (next.workflowPolicy)
+                                    delete next.workflowPolicy[field];
+                            }
+                            return next;
+                        }
+                        if (field in VALID_FIELDS) {
+                            const allowed = VALID_FIELDS[field];
+                            if (!allowed.includes(value))
+                                throw new Error(`Invalid value "${value}" for ${field}`);
+                            next[field] = value;
+                        }
+                        else if (NUMERIC_RETENTION_FIELDS.includes(field)) {
+                            const num = parseFloat(value);
+                            if (!Number.isFinite(num) || num < 0)
+                                throw new Error(`Invalid numeric value for ${field}`);
+                            next.retentionPolicy = { ...next.retentionPolicy, [field]: num };
+                        }
+                        else if (NUMERIC_WORKFLOW_FIELDS.includes(field)) {
+                            const num = parseFloat(value);
+                            if (!Number.isFinite(num) || num < 0 || num > 1)
+                                throw new Error(`Invalid value for ${field} (must be 0–1)`);
+                            next.workflowPolicy = { ...next.workflowPolicy, [field]: num };
+                        }
+                        else {
+                            throw new Error(`Unknown config field: ${field}`);
+                        }
+                        return next;
+                    });
+                    const merged = mergeConfig(phrenPath, project);
+                    res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+                    res.end(JSON.stringify({ ok: true, config: merged }));
+                }
+                catch (err) {
+                    res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+                    res.end(JSON.stringify({ ok: false, error: errorMessage(err) }));
+                }
+            });
+            return;
+        }
+        if (req.method === "GET" && pathname === "/api/config") {
+            if (!requireGetAuth(req, res, url, authToken, true))
+                return;
+            const qs = url.includes("?") ? querystring.parse(url.slice(url.indexOf("?") + 1)) : {};
+            const project = String(qs.project || "");
+            if (project && !isValidProjectName(project)) {
+                res.writeHead(400, { "content-type": "application/json" });
+                res.end(JSON.stringify({ ok: false, error: "Invalid project name" }));
+                return;
+            }
+            try {
+                const config = mergeConfig(phrenPath, project || undefined);
+                const projects = getProjectDirs(phrenPath, profile).map((d) => path.basename(d)).filter((p) => p !== "global");
+                res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+                res.end(JSON.stringify({ ok: true, config, projects }));
+            }
+            catch (err) {
+                res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+                res.end(JSON.stringify({ ok: false, error: errorMessage(err) }));
+            }
+            return;
+        }
         if (req.method === "GET" && pathname === "/api/csrf-token") {
             if (!requireGetAuth(req, res, url, authToken, true))
                 return;

package/mcp/dist/phren-paths.js

@@ -74,7 +74,7 @@ export function readRootManifest(phrenPath) {
         return normalizeManifest(parsed);
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] readRootManifest: ${errorMessage(err)}\n`);
         return null;
     }
@@ -250,7 +250,7 @@ export function sessionMarker(phrenPath, name) {
 }
 // Debug logging is best-effort and only writes when a phren root already exists.
 export function debugLog(msg) {
-    if (!(process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+    if (!(process.env.PHREN_DEBUG))
         return;
     const phrenPath = findPhrenPath();
     if (!phrenPath)
@@ -269,7 +269,7 @@ export function appendIndexEvent(phrenPath, event) {
         fs.appendFileSync(file, JSON.stringify({ at: new Date().toISOString(), ...event }) + "\n");
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] appendIndexEvent: ${errorMessage(err)}\n`);
     }
 }
@@ -301,7 +301,7 @@ export function findProjectNameCaseInsensitive(phrenPath, name) {
         }
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] findProjectNameCaseInsensitive: ${errorMessage(err)}\n`);
     }
     return null;
@@ -357,7 +357,7 @@ export function getProjectDirs(phrenPath, profile) {
             return [...new Set([...listed, ...sharedDirs])];
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            if ((process.env.PHREN_DEBUG))
                 process.stderr.write(`[phren] getProjectDirs yamlParse: ${errorMessage(err)}\n`);
             console.error(`${PhrenError.MALFORMED_YAML}: Malformed profile YAML: ${profilePath}`);
             return [];
@@ -369,7 +369,7 @@ export function getProjectDirs(phrenPath, profile) {
             .map((entry) => path.join(phrenPath, entry.name));
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] getProjectDirs: ${errorMessage(err)}\n`);
         return [];
     }
@@ -396,7 +396,7 @@ export function collectNativeMemoryFiles() {
         }
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] collectNativeMemoryFiles: ${errorMessage(err)}\n`);
     }
     return results;

package/mcp/dist/profile-store.js

@@ -73,7 +73,7 @@ export function listMachines(phrenPath) {
         return phrenOk(cleaned);
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] listMachines yaml parse: ${errorMessage(err)}\n`);
         return phrenErr(`Could not parse machines.yaml. Check the file for syntax errors or run 'phren doctor --fix'.`, PhrenError.MALFORMED_YAML);
     }
@@ -139,7 +139,7 @@ export function listProfiles(phrenPath) {
             profiles.push({ name, file: full, projects });
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            if ((process.env.PHREN_DEBUG))
                 process.stderr.write(`[phren] listProfiles yamlParse: ${errorMessage(err)}\n`);
             return phrenErr(`profiles/${file}`, PhrenError.MALFORMED_YAML);
         }

package/mcp/dist/project-config.js

@@ -4,7 +4,7 @@ import * as path from "path";
 import * as yaml from "js-yaml";
 import { readInstallPreferences } from "./init-preferences.js";
 import { debugLog } from "./shared.js";
-import { errorMessage } from "./utils.js";
+import { errorMessage, safeProjectPath } from "./utils.js";
 import { withFileLock } from "./governance-locks.js";
 export const PROJECT_OWNERSHIP_MODES = ["phren-managed", "detached", "repo-managed"];
 export const PROJECT_HOOK_EVENTS = ["UserPromptSubmit", "Stop", "SessionStart", "PostToolUse"];
@@ -24,22 +24,58 @@ export function parseProjectOwnershipMode(raw) {
 export function projectConfigPath(phrenPath, project) {
     return path.join(phrenPath, project, "phren.project.yaml");
 }
+function resolveProjectConfigPath(phrenPath, project) {
+    return safeProjectPath(phrenPath, project, "phren.project.yaml");
+}
+function writeProjectConfigFile(configPath, next) {
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    const tmpPath = `${configPath}.tmp-${crypto.randomUUID()}`;
+    fs.writeFileSync(tmpPath, yaml.dump(next, { lineWidth: 1000 }));
+    fs.renameSync(tmpPath, configPath);
+    _projectConfigCache.delete(configPath);
+}
+function normalizeProjectOverrides(raw) {
+    return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+}
+// ── mtime-based config cache ─────────────────────────────────────────────────
+const _projectConfigCache = new Map();
+export function clearProjectConfigCache() {
+    _projectConfigCache.clear();
+}
 export function readProjectConfig(phrenPath, project) {
-    const configPath = projectConfigPath(phrenPath, project);
-    if (!fs.existsSync(configPath))
+    const configPath = resolveProjectConfigPath(phrenPath, project);
+    if (!configPath) {
+        debugLog(`readProjectConfig: rejected path for project "${project}"`);
+        return {};
+    }
+    let mtimeMs;
+    try {
+        mtimeMs = fs.statSync(configPath).mtimeMs;
+    }
+    catch {
+        // File doesn't exist or can't be stat'd
+        _projectConfigCache.delete(configPath);
         return {};
+    }
+    const cached = _projectConfigCache.get(configPath);
+    if (cached && cached.mtimeMs === mtimeMs) {
+        return cached.config;
+    }
     try {
         const parsed = yaml.load(fs.readFileSync(configPath, "utf8"), { schema: yaml.CORE_SCHEMA });
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+        const config = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+        _projectConfigCache.set(configPath, { mtimeMs, config });
+        return config;
     }
     catch (err) {
         debugLog(`readProjectConfig: failed to parse ${configPath}: ${errorMessage(err)}`);
+        _projectConfigCache.delete(configPath);
         return {};
     }
 }
 export function writeProjectConfig(phrenPath, project, patch) {
-    const configPath = path.resolve(projectConfigPath(phrenPath, project));
-    if (!configPath.startsWith(phrenPath + path.sep) && configPath !== phrenPath) {
+    const configPath = resolveProjectConfigPath(phrenPath, project);
+    if (!configPath) {
         throw new Error(`Project config path escapes phren store`);
     }
     return withFileLock(configPath, () => {
@@ -48,10 +84,24 @@ export function writeProjectConfig(phrenPath, project, patch) {
             ...current,
             ...patch,
         };
-        fs.mkdirSync(path.dirname(configPath), { recursive: true });
-        const tmpPath = `${configPath}.tmp-${crypto.randomUUID()}`;
-        fs.writeFileSync(tmpPath, yaml.dump(next, { lineWidth: 1000 }));
-        fs.renameSync(tmpPath, configPath);
+        writeProjectConfigFile(configPath, next);
+        return next;
+    });
+}
+export function updateProjectConfigOverrides(phrenPath, project, updater) {
+    const configPath = resolveProjectConfigPath(phrenPath, project);
+    if (!configPath) {
+        throw new Error(`Project config path escapes phren store`);
+    }
+    return withFileLock(configPath, () => {
+        const current = readProjectConfig(phrenPath, project);
+        const currentConfig = normalizeProjectOverrides(current.config);
+        const nextOverrides = normalizeProjectOverrides(updater(currentConfig));
+        const next = {
+            ...current,
+            config: nextOverrides,
+        };
+        writeProjectConfigFile(configPath, next);
         return next;
     });
 }
@@ -82,8 +132,8 @@ export function isProjectHookEnabled(phrenPath, project, event, config) {
 }
 export function writeProjectHookConfig(phrenPath, project, patch) {
     // Move read+merge inside the lock so concurrent writers cannot clobber each other.
-    const configPath = path.resolve(projectConfigPath(phrenPath, project));
-    if (!configPath.startsWith(phrenPath + path.sep) && configPath !== phrenPath) {
+    const configPath = resolveProjectConfigPath(phrenPath, project);
+    if (!configPath) {
         throw new Error(`Project config path escapes phren store`);
     }
     return withFileLock(configPath, () => {
@@ -95,10 +145,7 @@ export function writeProjectHookConfig(phrenPath, project, patch) {
                 ...patch,
             },
         };
-        fs.mkdirSync(path.dirname(configPath), { recursive: true });
-        const tmpPath = `${configPath}.tmp-${crypto.randomUUID()}`;
-        fs.writeFileSync(tmpPath, yaml.dump(next, { lineWidth: 1000 }));
-        fs.renameSync(tmpPath, configPath);
+        writeProjectConfigFile(configPath, next);
         return next;
     });
 }

package/mcp/dist/session-utils.js

@@ -1,5 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
+import { errorMessage } from "./utils.js";
 /**
  * Write JSON to a file atomically using temp-file + rename.
  * Ensures the parent directory exists before writing.
@@ -15,8 +16,8 @@ export function atomicWriteJson(filePath, data) {
  * Centralises the repeated `if (PHREN_DEBUG) stderr.write(...)` pattern.
  */
 export function debugError(scope, err) {
-    if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG)) {
-        process.stderr.write(`[phren] ${scope}: ${err instanceof Error ? err.message : String(err)}\n`);
+    if ((process.env.PHREN_DEBUG)) {
+        process.stderr.write(`[phren] ${scope}: ${errorMessage(err)}\n`);
     }
 }
 /**

package/mcp/dist/shared-fragment-graph.js

@@ -2,6 +2,7 @@ import { decodeStringRow } from "./shared-index.js";
 import * as fs from "fs";
 import { runtimeFile } from "./shared.js";
 import { UNIVERSAL_TECH_TERMS_RE } from "./phren-core.js";
+import { errorMessage } from "./utils.js";
 export function escapeRegex(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
 /** Escape SQL LIKE wildcard characters so user input is treated literally. */
 export function escapeLike(s) { return s.replace(/[%_\\]/g, '\\$&'); }
@@ -21,7 +22,7 @@ export function escapeLike(s) { return s.replace(/[%_\\]/g, '\\$&'); }
  * found" -> suggest adding it).
  */
 export function logFragmentMiss(phrenPath, name, context, project) {
-    if (!process.env.PHREN_DEBUG && !(process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+    if (!process.env.PHREN_DEBUG && !(process.env.PHREN_DEBUG))
         return;
     if (!name || name.length <= 2)
         return;
@@ -115,8 +116,8 @@ function getOrCreateFragment(db, name, type) {
         db.run("INSERT OR IGNORE INTO entities (name, type, first_seen_at) VALUES (?, ?, ?)", [name, type, new Date().toISOString().slice(0, 10)]);
     }
     catch (err) {
-        if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-            process.stderr.write(`[phren] fragmentInsert: ${err instanceof Error ? err.message : String(err)}\n`);
+        if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG))
+            process.stderr.write(`[phren] fragmentInsert: ${errorMessage(err)}\n`);
     }
     const result = db.exec("SELECT id FROM entities WHERE name = ? AND type = ?", [name, type]);
     if (result?.length && result[0]?.values?.length) {
@@ -138,8 +139,8 @@ export function ensureGlobalEntitiesTable(db) {
       )`);
     }
     catch (err) {
-        if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-            process.stderr.write(`[phren] ensureGlobalEntitiesTable: ${err instanceof Error ? err.message : String(err)}\n`);
+        if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG))
+            process.stderr.write(`[phren] ensureGlobalEntitiesTable: ${errorMessage(err)}\n`);
     }
 }
 /**
@@ -185,8 +186,8 @@ export function beginUserFragmentBuildCache(phrenPath, projects) {
             _buildUserFragmentCache.set(cacheKey, loaded.fragments);
         }
         catch (err) {
-            if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-                process.stderr.write(`[phren] beginUserFragmentBuildCache: ${err instanceof Error ? err.message : String(err)}\n`);
+            if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG))
+                process.stderr.write(`[phren] beginUserFragmentBuildCache: ${errorMessage(err)}\n`);
             _buildUserFragmentCache.set(cacheKey, []);
         }
     }
@@ -224,8 +225,8 @@ function parseUserDefinedFragments(phrenPath, project) {
                 }
             }
             catch (err) {
-                if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-                    process.stderr.write(`[phren] parseUserDefinedFragments statCheck: ${err instanceof Error ? err.message : String(err)}\n`);
+                if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG))
+                    process.stderr.write(`[phren] parseUserDefinedFragments statCheck: ${errorMessage(err)}\n`);
             }
         }
         const loaded = readUserDefinedFragmentsFromDisk(claudeMdPath);
@@ -235,8 +236,8 @@ function parseUserDefinedFragments(phrenPath, project) {
         return loaded.fragments;
     }
     catch (err) {
-        if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-            process.stderr.write(`[phren] parseUserDefinedFragments: ${err instanceof Error ? err.message : String(err)}\n`);
+        if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG))
+            process.stderr.write(`[phren] parseUserDefinedFragments: ${errorMessage(err)}\n`);
         return [];
     }
 }
@@ -352,8 +353,8 @@ export function extractAndLinkFragments(db, content, sourceDoc, phrenPath) {
             db.run("INSERT OR IGNORE INTO entity_links (source_id, target_id, rel_type, source_doc) VALUES (?, ?, ?, ?)", [docFragmentId, fragmentId, "mentions", sourceDoc]);
         }
         catch (err) {
-            if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-                process.stderr.write(`[phren] fragmentLinksInsert: ${err instanceof Error ? err.message : String(err)}\n`);
+            if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG))
+                process.stderr.write(`[phren] fragmentLinksInsert: ${errorMessage(err)}\n`);
         }
         // Write to global_entities for cross-project queries
         if (project) {
@@ -361,8 +362,8 @@ export function extractAndLinkFragments(db, content, sourceDoc, phrenPath) {
                 db.run("INSERT OR IGNORE INTO global_entities (entity, project, doc_key) VALUES (?, ?, ?)", [name, project, sourceDoc]);
             }
             catch (err) {
-                if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-                    process.stderr.write(`[phren] globalFragmentsInsert: ${err instanceof Error ? err.message : String(err)}\n`);
+                if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG))
+                    process.stderr.write(`[phren] globalFragmentsInsert: ${errorMessage(err)}\n`);
             }
         }
     }
@@ -390,8 +391,8 @@ export function queryFragmentLinks(db, name) {
         }
     }
     catch (err) {
-        if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-            process.stderr.write(`[phren] queryFragmentLinks: ${err instanceof Error ? err.message : String(err)}\n`);
+        if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG))
+            process.stderr.write(`[phren] queryFragmentLinks: ${errorMessage(err)}\n`);
     }
     return { related };
 }
@@ -426,8 +427,8 @@ export function queryCrossProjectFragments(db, fragmentName, excludeProject) {
         }
     }
     catch (err) {
-        if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-            process.stderr.write(`[phren] queryCrossProjectFragments: ${err instanceof Error ? err.message : String(err)}\n`);
+        if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG))
+            process.stderr.write(`[phren] queryCrossProjectFragments: ${errorMessage(err)}\n`);
     }
     return results;
 }
@@ -447,8 +448,8 @@ export function getFragmentBoostDocs(db, query) {
         return boostDocs;
     }
     catch (err) {
-        if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-            process.stderr.write(`[phren] getFragmentBoostDocs: ${err instanceof Error ? err.message : String(err)}\n`);
+        if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG))
+            process.stderr.write(`[phren] getFragmentBoostDocs: ${errorMessage(err)}\n`);
         return new Set();
     }
 }