@phren/cli 0.0.10 → 0.0.12

package/mcp/dist/phren-paths.js

@@ -4,7 +4,7 @@ import * as path from "path";
 import * as crypto from "crypto";
 import * as yaml from "js-yaml";
 import { bootstrapPhrenDotEnv } from "./phren-dotenv.js";
-import { PhrenError, isRecord } from "./phren-core.js";
+import { PhrenError, isRecord, RESERVED_PROJECT_DIR_NAMES } from "./phren-core.js";
 import { errorMessage, isValidProjectName, safeProjectPath } from "./utils.js";
 bootstrapPhrenDotEnv();
 export const ROOT_MANIFEST_FILENAME = "phren.root.yaml";
@@ -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`);
     }
 }
@@ -280,7 +280,6 @@ export function resolveFindingsPath(projectDir) {
         return findingsPath;
     return undefined;
 }
-const RESERVED_PROJECT_DIR_NAMES = new Set(["profiles", "templates", "global"]);
 function isProjectDirEntry(entry) {
     return entry.isDirectory()
         && !entry.name.startsWith(".")
@@ -301,7 +300,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 +356,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 +368,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 +395,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/proactivity.js

@@ -93,21 +93,21 @@ function resolveProactivityLevel(raw, fallback) {
 }
 export function getProactivityLevel(explicitPhrenPath) {
     bootstrapPhrenDotEnv();
-    return resolveProactivityLevel(process.env.PHREN_PROACTIVITY ?? (process.env.PHREN_PROACTIVITY), getConfiguredProactivityDefault(explicitPhrenPath));
+    return resolveProactivityLevel(process.env.PHREN_PROACTIVITY, getConfiguredProactivityDefault(explicitPhrenPath));
 }
 export function getProactivityLevelForFindings(explicitPhrenPath) {
     bootstrapPhrenDotEnv();
-    const findingsPreference = parseProactivityLevel(process.env.PHREN_PROACTIVITY_FINDINGS ?? (process.env.PHREN_PROACTIVITY_FINDINGS));
+    const findingsPreference = parseProactivityLevel(process.env.PHREN_PROACTIVITY_FINDINGS);
     if (findingsPreference)
         return findingsPreference;
-    return resolveProactivityLevel(process.env.PHREN_PROACTIVITY ?? (process.env.PHREN_PROACTIVITY), getConfiguredProactivityLevelForFindingsDefault(explicitPhrenPath));
+    return resolveProactivityLevel(process.env.PHREN_PROACTIVITY, getConfiguredProactivityLevelForFindingsDefault(explicitPhrenPath));
 }
 export function getProactivityLevelForTask(explicitPhrenPath) {
     bootstrapPhrenDotEnv();
-    const taskPreference = parseProactivityLevel(process.env.PHREN_PROACTIVITY_TASKS ?? (process.env.PHREN_PROACTIVITY_TASKS));
+    const taskPreference = parseProactivityLevel(process.env.PHREN_PROACTIVITY_TASKS);
     if (taskPreference)
         return taskPreference;
-    return resolveProactivityLevel(process.env.PHREN_PROACTIVITY ?? (process.env.PHREN_PROACTIVITY), getConfiguredProactivityLevelForTaskDefault(explicitPhrenPath));
+    return resolveProactivityLevel(process.env.PHREN_PROACTIVITY, getConfiguredProactivityLevelForTaskDefault(explicitPhrenPath));
 }
 export function hasExplicitFindingSignal(...texts) {
     return texts.some((text) => {

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,8 +4,8 @@ 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 { withFileLock } from "./governance-locks.js";
+import { errorMessage, safeProjectPath } from "./utils.js";
+import { withFileLock } from "./shared-governance.js";
 export const PROJECT_OWNERSHIP_MODES = ["phren-managed", "detached", "repo-managed"];
 export const PROJECT_HOOK_EVENTS = ["UserPromptSubmit", "Stop", "SessionStart", "PostToolUse"];
 export function parseProjectOwnershipMode(raw) {
@@ -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/provider-adapters.js

@@ -18,7 +18,7 @@ function homePathForEnv(env, ...parts) {
     return joinPortable(homeDir(env), ...parts);
 }
 function defaultPhrenPath(env = process.env) {
-    return env.PHREN_PATH || env.PHREN_PATH || homePathForEnv(env, ".phren");
+    return env.PHREN_PATH || homePathForEnv(env, ".phren");
 }
 function normalizeWindowsPathToWsl(input) {
     if (!input)

package/mcp/dist/query-correlation.js

@@ -7,6 +7,7 @@
 import * as fs from "fs";
 import { runtimeFile, debugLog } from "./shared.js";
 import { isFeatureEnabled, errorMessage } from "./utils.js";
+import { withFileLock } from "./shared-governance.js";
 const CORRELATION_FILENAME = "query-correlations.jsonl";
 const RECENT_WINDOW = 500;
 const MIN_TOKEN_OVERLAP = 2;
@@ -56,28 +57,30 @@ export function markCorrelationsHelpful(phrenPath, sessionId, docKey) {
         const correlationFile = runtimeFile(phrenPath, CORRELATION_FILENAME);
         if (!fs.existsSync(correlationFile))
             return;
-        const raw = fs.readFileSync(correlationFile, "utf8");
-        const lines = raw.split("\n").filter(Boolean);
-        let modified = false;
-        const updated = lines.map((line) => {
-            try {
-                const entry = JSON.parse(line);
-                if (entry.sessionId === sessionId &&
-                    `${entry.project}/${entry.filename}` === docKey &&
-                    !entry.helpful) {
-                    entry.helpful = true;
-                    modified = true;
-                    return JSON.stringify(entry);
+        withFileLock(correlationFile, () => {
+            const raw = fs.readFileSync(correlationFile, "utf8");
+            const lines = raw.split("\n").filter(Boolean);
+            let modified = false;
+            const updated = lines.map((line) => {
+                try {
+                    const entry = JSON.parse(line);
+                    if (entry.sessionId === sessionId &&
+                        `${entry.project}/${entry.filename}` === docKey &&
+                        !entry.helpful) {
+                        entry.helpful = true;
+                        modified = true;
+                        return JSON.stringify(entry);
+                    }
                 }
+                catch {
+                    // keep original line
+                }
+                return line;
+            });
+            if (modified) {
+                fs.writeFileSync(correlationFile, updated.join("\n") + "\n");
             }
-            catch {
-                // keep original line
-            }
-            return line;
         });
-        if (modified) {
-            fs.writeFileSync(correlationFile, updated.join("\n") + "\n");
-        }
     }
     catch (err) {
         debugLog(`query-correlation mark-helpful failed: ${errorMessage(err)}`);

package/mcp/dist/session-checkpoints.js

@@ -110,21 +110,21 @@ export function clearTaskCheckpoint(phrenPath, args) {
             debugLog(`checkpoint clear ${filePath}: ${errorMessage(err)}`);
         }
     }
-    const allProjectCheckpoints = listTaskCheckpoints(phrenPath, args.project);
-    for (const checkpoint of allProjectCheckpoints) {
-        const idMatch = ids.size > 0 && ids.has(checkpoint.taskId);
-        const lineMatch = args.taskLine && checkpoint.taskLine === args.taskLine;
-        if (!idMatch && !lineMatch)
-            continue;
-        const filePath = checkpointPath(phrenPath, checkpoint.project, checkpoint.taskId);
-        try {
-            if (fs.existsSync(filePath)) {
-                fs.unlinkSync(filePath);
-                removed++;
+    if (args.taskLine) {
+        const allProjectCheckpoints = listTaskCheckpoints(phrenPath, args.project);
+        for (const checkpoint of allProjectCheckpoints) {
+            if (checkpoint.taskLine !== args.taskLine)
+                continue;
+            const filePath = checkpointPath(phrenPath, checkpoint.project, checkpoint.taskId);
+            try {
+                if (fs.existsSync(filePath)) {
+                    fs.unlinkSync(filePath);
+                    removed++;
+                }
+            }
+            catch (err) {
+                debugLog(`checkpoint clear scan ${filePath}: ${errorMessage(err)}`);
             }
-        }
-        catch (err) {
-            debugLog(`checkpoint clear scan ${filePath}: ${errorMessage(err)}`);
         }
     }
     return removed;

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-data-utils.js

@@ -0,0 +1,28 @@
+import * as fs from "fs";
+import * as path from "path";
+import { phrenErr, PhrenError, phrenOk, } from "./shared.js";
+import { withFileLock as withFileLockRaw } from "./shared-governance.js";
+import { isValidProjectName, safeProjectPath, errorMessage } from "./utils.js";
+export function withSafeLock(filePath, fn) {
+    try {
+        return withFileLockRaw(filePath, fn);
+    }
+    catch (err) {
+        const msg = errorMessage(err);
+        if (msg.includes("could not acquire lock")) {
+            return phrenErr(`Could not acquire write lock for "${path.basename(filePath)}". Another write may be in progress; please retry.`, PhrenError.LOCK_TIMEOUT);
+        }
+        throw err;
+    }
+}
+export function ensureProject(phrenPath, project) {
+    if (!isValidProjectName(project))
+        return phrenErr(`Project name "${project}" is not valid. Use lowercase letters, numbers, and hyphens (e.g. "my-project").`, PhrenError.INVALID_PROJECT_NAME);
+    const dir = safeProjectPath(phrenPath, project);
+    if (!dir)
+        return phrenErr(`Project name "${project}" is not valid. Use lowercase letters, numbers, and hyphens (e.g. "my-project").`, PhrenError.INVALID_PROJECT_NAME);
+    if (!fs.existsSync(dir)) {
+        return phrenErr(`No project "${project}" found. Add it with 'cd ~/your-project && phren add'.`, PhrenError.PROJECT_NOT_FOUND);
+    }
+    return phrenOk(dir);
+}

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)
         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.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.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.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.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.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.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.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.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.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.stderr.write(`[phren] getFragmentBoostDocs: ${errorMessage(err)}\n`);
         return new Set();
     }
 }

package/mcp/dist/shared-governance.js

@@ -1,4 +1,4 @@
 export * from './governance-policy.js';
 export * from './governance-scores.js';
 export * from './governance-audit.js';
-export { withFileLock } from './governance-locks.js';
+export { withFileLock, isFiniteNumber, hasValidSchemaVersion } from './governance-locks.js';