@phren/cli 0.0.9 → 0.0.11

package/mcp/dist/mcp-config.js

@@ -1,27 +1,38 @@
 import { mcpResponse } from "./mcp-types.js";
 import { z } from "zod";
-import { getRetentionPolicy, updateRetentionPolicy, getWorkflowPolicy, updateWorkflowPolicy, getIndexPolicy, updateIndexPolicy, } from "./shared-governance.js";
-import { PROACTIVITY_LEVELS, getProactivityLevel, getProactivityLevelForFindings, getProactivityLevelForTask, } from "./proactivity.js";
-import { readGovernanceInstallPreferences, writeGovernanceInstallPreferences, } from "./init-preferences.js";
-import { FINDING_SENSITIVITY_CONFIG } from "./cli-config.js";
+import { getRetentionPolicy, updateRetentionPolicy, getWorkflowPolicy, updateWorkflowPolicy, getIndexPolicy, updateIndexPolicy, mergeConfig, VALID_TASK_MODES, VALID_FINDING_SENSITIVITY, } from "./shared-governance.js";
+import { PROACTIVITY_LEVELS, } from "./proactivity.js";
+import { writeGovernanceInstallPreferences, } from "./init-preferences.js";
+import { FINDING_SENSITIVITY_CONFIG, buildProactivitySnapshot, checkProjectInProfile } from "./cli-config.js";
+import { readProjectConfig, updateProjectConfigOverrides, } from "./project-config.js";
+import { isValidProjectName } from "./utils.js";
 // ── Helpers ─────────────────────────────────────────────────────────────────
 function proactivitySnapshot(phrenPath) {
-    const prefs = readGovernanceInstallPreferences(phrenPath);
-    return {
-        configured: {
-            proactivity: prefs.proactivity ?? null,
-            proactivityFindings: prefs.proactivityFindings ?? null,
-            proactivityTask: prefs.proactivityTask ?? null,
-        },
-        effective: {
-            proactivity: getProactivityLevel(phrenPath),
-            proactivityFindings: getProactivityLevelForFindings(phrenPath),
-            proactivityTask: getProactivityLevelForTask(phrenPath),
-        },
-    };
+    const snap = buildProactivitySnapshot(phrenPath);
+    return { configured: snap.configured, effective: snap.effective };
 }
-const TASK_MODES = ["off", "manual", "suggest", "auto"];
-const FINDING_SENSITIVITY_LEVELS = ["minimal", "conservative", "balanced", "aggressive"];
+function validateProject(project) {
+    if (!isValidProjectName(project))
+        return `Invalid project name: "${project}".`;
+    return null;
+}
+function checkProjectRegistered(phrenPath, project) {
+    const warning = checkProjectInProfile(phrenPath, project);
+    if (warning) {
+        return `Project '${project}' is not registered in your active profile. Config was written but won't take effect until you run 'phren add' to register the project.`;
+    }
+    return null;
+}
+function normalizeProjectOverrides(raw) {
+    return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+}
+function getProjectOverrides(phrenPath, project) {
+    return normalizeProjectOverrides(readProjectConfig(phrenPath, project).config);
+}
+function hasOwnOverride(overrides, key) {
+    return Object.prototype.hasOwnProperty.call(overrides, key);
+}
+const projectParam = z.string().optional().describe("Project name. When provided, writes to that project's phren.project.yaml instead of global .governance/.");
 // ── Registration ────────────────────────────────────────────────────────────
 export function register(server, ctx) {
     const { phrenPath } = ctx;
@@ -30,15 +41,86 @@ export function register(server, ctx) {
         title: "◆ phren · get config",
         description: "Read current configuration for one or all config domains: proactivity, taskMode, " +
             "findingSensitivity, retention (policy), workflow, access, index. " +
-            "Returns both configured and effective values.",
+            "Returns both configured and effective values. When project is provided, returns " +
+            "the merged view with project overrides applied and _source annotations.",
         inputSchema: z.object({
             domain: z
                 .enum(["proactivity", "taskMode", "findingSensitivity", "retention", "workflow", "access", "index", "all"])
                 .optional()
                 .describe("Config domain to read. Defaults to 'all'."),
+            project: projectParam,
         }),
-    }, async ({ domain }) => {
+    }, async ({ domain, project }) => {
         const d = domain ?? "all";
+        if (project) {
+            const err = validateProject(project);
+            if (err)
+                return mcpResponse({ ok: false, error: err });
+            const resolved = mergeConfig(phrenPath, project);
+            const projectOverrides = getProjectOverrides(phrenPath, project);
+            function src(key) {
+                return hasOwnOverride(projectOverrides, key) ? "project" : "global";
+            }
+            const result = {
+                _project: project,
+                _note: "Values marked _source=project override the global default.",
+            };
+            if (d === "all" || d === "findingSensitivity") {
+                const level = resolved.findingSensitivity;
+                result.findingSensitivity = {
+                    level,
+                    ...FINDING_SENSITIVITY_CONFIG[level],
+                    _source: src("findingSensitivity"),
+                };
+            }
+            if (d === "all" || d === "taskMode") {
+                result.taskMode = { taskMode: resolved.taskMode, _source: src("taskMode") };
+            }
+            if (d === "all" || d === "retention") {
+                result.retention = {
+                    ...resolved.retentionPolicy,
+                    _source: hasOwnOverride(projectOverrides, "retentionPolicy") ? "project" : "global",
+                };
+            }
+            if (d === "all" || d === "workflow") {
+                result.workflow = {
+                    ...resolved.workflowPolicy,
+                    _source: hasOwnOverride(projectOverrides, "workflowPolicy") ? "project" : "global",
+                };
+            }
+            if (d === "all" || d === "proactivity") {
+                const globalSnapshot = proactivitySnapshot(phrenPath).effective;
+                const base = resolved.proactivity.base ?? globalSnapshot.proactivity;
+                const findings = resolved.proactivity.findings ?? resolved.proactivity.base ?? globalSnapshot.proactivityFindings;
+                const tasks = resolved.proactivity.tasks ?? resolved.proactivity.base ?? globalSnapshot.proactivityTask;
+                result.proactivity = {
+                    base,
+                    findings,
+                    tasks,
+                    _source: {
+                        base: hasOwnOverride(projectOverrides, "proactivity") ? "project" : "global",
+                        findings: hasOwnOverride(projectOverrides, "proactivityFindings")
+                            ? "project"
+                            : hasOwnOverride(projectOverrides, "proactivity")
+                                ? "project"
+                                : "global",
+                        tasks: hasOwnOverride(projectOverrides, "proactivityTask")
+                            ? "project"
+                            : hasOwnOverride(projectOverrides, "proactivity")
+                                ? "project"
+                                : "global",
+                    },
+                };
+            }
+            if (d === "all" || d === "index") {
+                result.index = getIndexPolicy(phrenPath);
+            }
+            return mcpResponse({
+                ok: true,
+                message: `Config for ${d === "all" ? "all domains" : d} (project: ${project}).`,
+                data: result,
+            });
+        }
         const result = {};
         if (d === "all" || d === "proactivity") {
             result.proactivity = proactivitySnapshot(phrenPath);
@@ -72,16 +154,36 @@ export function register(server, ctx) {
     server.registerTool("set_proactivity", {
         title: "◆ phren · set proactivity",
         description: "Set the proactivity level for auto-capture. Controls how aggressively phren " +
-            "captures findings and tasks. Supports base level, findings-specific, and task-specific overrides.",
+            "captures findings and tasks. Supports base level, findings-specific, and task-specific overrides. " +
+            "When project is provided, writes to that project's phren.project.yaml.",
         inputSchema: z.object({
             level: z.enum(PROACTIVITY_LEVELS).describe("Proactivity level: high, medium, or low."),
             scope: z
                 .enum(["base", "findings", "tasks"])
                 .optional()
                 .describe("Which proactivity to set. Defaults to 'base'."),
+            project: projectParam,
         }),
-    }, async ({ level, scope }) => {
+    }, async ({ level, scope, project }) => {
         const s = scope ?? "base";
+        if (project) {
+            const err = validateProject(project);
+            if (err)
+                return mcpResponse({ ok: false, error: err });
+            const warning = checkProjectRegistered(phrenPath, project);
+            const key = s === "base" ? "proactivity" : s === "findings" ? "proactivityFindings" : "proactivityTask";
+            updateProjectConfigOverrides(phrenPath, project, (current) => ({
+                ...current,
+                [key]: level,
+            }));
+            return mcpResponse({
+                ok: true,
+                message: warning
+                    ? `Proactivity ${s} set to ${level} for project "${project}". WARNING: ${warning}`
+                    : `Proactivity ${s} set to ${level} for project "${project}".`,
+                data: { project, scope: s, level, ...(warning ? { warning } : {}) },
+            });
+        }
         const patch = {};
         if (s === "base")
             patch.proactivity = level;
@@ -100,11 +202,30 @@ export function register(server, ctx) {
     server.registerTool("set_task_mode", {
         title: "◆ phren · set task mode",
         description: "Set the task automation mode: off (no auto-tasks), manual (user creates), " +
-            "suggest (phren suggests, user approves), auto (phren creates automatically).",
+            "suggest (phren suggests, user approves), auto (phren creates automatically). " +
+            "When project is provided, writes to that project's phren.project.yaml.",
         inputSchema: z.object({
-            mode: z.enum(TASK_MODES).describe("Task mode: off, manual, suggest, or auto."),
+            mode: z.enum(VALID_TASK_MODES).describe("Task mode: off, manual, suggest, or auto."),
+            project: projectParam,
         }),
-    }, async ({ mode }) => {
+    }, async ({ mode, project }) => {
+        if (project) {
+            const err = validateProject(project);
+            if (err)
+                return mcpResponse({ ok: false, error: err });
+            const warning = checkProjectRegistered(phrenPath, project);
+            updateProjectConfigOverrides(phrenPath, project, (current) => ({
+                ...current,
+                taskMode: mode,
+            }));
+            return mcpResponse({
+                ok: true,
+                message: warning
+                    ? `Task mode set to ${mode} for project "${project}". WARNING: ${warning}`
+                    : `Task mode set to ${mode} for project "${project}".`,
+                data: { project, taskMode: mode, ...(warning ? { warning } : {}) },
+            });
+        }
         const result = updateWorkflowPolicy(phrenPath, { taskMode: mode });
         if (!result.ok) {
             return mcpResponse({ ok: false, error: result.error, errorCode: result.code });
@@ -120,11 +241,31 @@ export function register(server, ctx) {
         title: "◆ phren · set finding sensitivity",
         description: "Set the finding capture sensitivity level. Controls how many findings phren captures per session. " +
             "minimal: only explicit asks. conservative: decisions/pitfalls only. " +
-            "balanced: non-obvious patterns. aggressive: capture everything.",
+            "balanced: non-obvious patterns. aggressive: capture everything. " +
+            "When project is provided, writes to that project's phren.project.yaml.",
         inputSchema: z.object({
-            level: z.enum(FINDING_SENSITIVITY_LEVELS).describe("Sensitivity level."),
+            level: z.enum(VALID_FINDING_SENSITIVITY).describe("Sensitivity level."),
+            project: projectParam,
         }),
-    }, async ({ level }) => {
+    }, async ({ level, project }) => {
+        if (project) {
+            const err = validateProject(project);
+            if (err)
+                return mcpResponse({ ok: false, error: err });
+            const warning = checkProjectRegistered(phrenPath, project);
+            updateProjectConfigOverrides(phrenPath, project, (current) => ({
+                ...current,
+                findingSensitivity: level,
+            }));
+            const config = FINDING_SENSITIVITY_CONFIG[level];
+            return mcpResponse({
+                ok: true,
+                message: warning
+                    ? `Finding sensitivity set to ${level} for project "${project}". WARNING: ${warning}`
+                    : `Finding sensitivity set to ${level} for project "${project}".`,
+                data: { project, level, ...config, ...(warning ? { warning } : {}) },
+            });
+        }
         const result = updateWorkflowPolicy(phrenPath, { findingSensitivity: level });
         if (!result.ok) {
             return mcpResponse({ ok: false, error: result.error, errorCode: result.code });
@@ -140,7 +281,8 @@ export function register(server, ctx) {
     server.registerTool("set_retention_policy", {
         title: "◆ phren · set retention policy",
         description: "Update memory retention policy: TTL, retention days, auto-accept threshold, " +
-            "minimum injection confidence, and decay curve.",
+            "minimum injection confidence, and decay curve. " +
+            "When project is provided, writes to that project's phren.project.yaml.",
         inputSchema: z.object({
             ttlDays: z.number().int().min(1).optional().describe("Days before a finding is considered for expiry."),
             retentionDays: z.number().int().min(1).optional().describe("Hard retention limit in days."),
@@ -155,20 +297,49 @@ export function register(server, ctx) {
             })
                 .optional()
                 .describe("Decay multipliers at 30/60/90/120 day marks."),
+            project: projectParam,
         }),
-    }, async ({ ttlDays, retentionDays, autoAcceptThreshold, minInjectConfidence, decay }) => {
-        const patch = {};
+    }, async ({ ttlDays, retentionDays, autoAcceptThreshold, minInjectConfidence, decay, project }) => {
+        if (project) {
+            const err = validateProject(project);
+            if (err)
+                return mcpResponse({ ok: false, error: err });
+            const warning = checkProjectRegistered(phrenPath, project);
+            const next = updateProjectConfigOverrides(phrenPath, project, (current) => {
+                const existingRetention = current.retentionPolicy ?? {};
+                const retentionPatch = { ...existingRetention };
+                if (ttlDays !== undefined)
+                    retentionPatch.ttlDays = ttlDays;
+                if (retentionDays !== undefined)
+                    retentionPatch.retentionDays = retentionDays;
+                if (autoAcceptThreshold !== undefined)
+                    retentionPatch.autoAcceptThreshold = autoAcceptThreshold;
+                if (minInjectConfidence !== undefined)
+                    retentionPatch.minInjectConfidence = minInjectConfidence;
+                if (decay !== undefined)
+                    retentionPatch.decay = { ...(existingRetention.decay ?? {}), ...decay };
+                return { ...current, retentionPolicy: retentionPatch };
+            });
+            return mcpResponse({
+                ok: true,
+                message: warning
+                    ? `Retention policy updated for project "${project}". WARNING: ${warning}`
+                    : `Retention policy updated for project "${project}".`,
+                data: { project, retentionPolicy: next.config?.retentionPolicy ?? {}, ...(warning ? { warning } : {}) },
+            });
+        }
+        const globalPatch = {};
         if (ttlDays !== undefined)
-            patch.ttlDays = ttlDays;
+            globalPatch.ttlDays = ttlDays;
         if (retentionDays !== undefined)
-            patch.retentionDays = retentionDays;
+            globalPatch.retentionDays = retentionDays;
         if (autoAcceptThreshold !== undefined)
-            patch.autoAcceptThreshold = autoAcceptThreshold;
+            globalPatch.autoAcceptThreshold = autoAcceptThreshold;
         if (minInjectConfidence !== undefined)
-            patch.minInjectConfidence = minInjectConfidence;
+            globalPatch.minInjectConfidence = minInjectConfidence;
         if (decay !== undefined)
-            patch.decay = decay;
-        const result = updateRetentionPolicy(phrenPath, patch);
+            globalPatch.decay = decay;
+        const result = updateRetentionPolicy(phrenPath, globalPatch);
         if (!result.ok) {
             return mcpResponse({ ok: false, error: result.error, errorCode: result.code });
         }
@@ -182,18 +353,52 @@ export function register(server, ctx) {
     server.registerTool("set_workflow_policy", {
         title: "◆ phren · set workflow policy",
         description: "Update workflow policy: low-confidence threshold, " +
-            "risky sections list, task mode, and finding sensitivity.",
+            "risky sections list, task mode, and finding sensitivity. " +
+            "When project is provided, writes to that project's phren.project.yaml.",
         inputSchema: z.object({
             lowConfidenceThreshold: z.number().min(0).max(1).optional()
                 .describe("Confidence below which items are flagged as low-confidence."),
             riskySections: z.array(z.enum(["Review", "Stale", "Conflicts"])).optional()
                 .describe("Which queue sections are considered risky."),
-            taskMode: z.enum(TASK_MODES).optional()
+            taskMode: z.enum(VALID_TASK_MODES).optional()
                 .describe("Task automation mode."),
-            findingSensitivity: z.enum(FINDING_SENSITIVITY_LEVELS).optional()
+            findingSensitivity: z.enum(VALID_FINDING_SENSITIVITY).optional()
                 .describe("Finding capture sensitivity."),
+            project: projectParam,
         }),
-    }, async ({ lowConfidenceThreshold, riskySections, taskMode, findingSensitivity }) => {
+    }, async ({ lowConfidenceThreshold, riskySections, taskMode, findingSensitivity, project }) => {
+        if (project) {
+            const err = validateProject(project);
+            if (err)
+                return mcpResponse({ ok: false, error: err });
+            const warning = checkProjectRegistered(phrenPath, project);
+            const next = updateProjectConfigOverrides(phrenPath, project, (current) => {
+                const nextConfig = { ...current };
+                const shouldUpdateWorkflowPolicy = (lowConfidenceThreshold !== undefined
+                    || riskySections !== undefined
+                    || current.workflowPolicy !== undefined);
+                if (shouldUpdateWorkflowPolicy) {
+                    const existingWorkflow = current.workflowPolicy ?? {};
+                    nextConfig.workflowPolicy = {
+                        ...existingWorkflow,
+                        ...(lowConfidenceThreshold !== undefined ? { lowConfidenceThreshold } : {}),
+                        ...(riskySections !== undefined ? { riskySections } : {}),
+                    };
+                }
+                if (taskMode !== undefined)
+                    nextConfig.taskMode = taskMode;
+                if (findingSensitivity !== undefined)
+                    nextConfig.findingSensitivity = findingSensitivity;
+                return nextConfig;
+            });
+            return mcpResponse({
+                ok: true,
+                message: warning
+                    ? `Workflow policy updated for project "${project}". WARNING: ${warning}`
+                    : `Workflow policy updated for project "${project}".`,
+                data: { project, config: next.config ?? {}, ...(warning ? { warning } : {}) },
+            });
+        }
         const patch = {};
         if (lowConfidenceThreshold !== undefined)
             patch.lowConfidenceThreshold = lowConfidenceThreshold;

package/mcp/dist/mcp-data.js

@@ -2,7 +2,7 @@ import { mcpResponse } from "./mcp-types.js";
 import { z } from "zod";
 import * as fs from "fs";
 import * as path from "path";
-import { isValidProjectName } from "./utils.js";
+import { isValidProjectName, errorMessage } from "./utils.js";
 import { readFindings, readTasks, resolveTaskFilePath, TASKS_FILENAME } from "./data-access.js";
 import { debugLog, findProjectNameCaseInsensitive, normalizeProjectNameForCreate } from "./shared.js";
 const importPayloadSchema = z.object({
@@ -75,8 +75,8 @@ export function register(server, ctx) {
                 decoded = JSON.parse(rawData);
             }
             catch (err) {
-                if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-                    process.stderr.write(`[phren] import_project jsonParse: ${err instanceof Error ? err.message : String(err)}\n`);
+                if ((process.env.PHREN_DEBUG))
+                    process.stderr.write(`[phren] import_project jsonParse: ${errorMessage(err)}\n`);
                 return mcpResponse({ ok: false, error: "Invalid JSON input." });
             }
             const parsedResult = importPayloadSchema.safeParse(decoded);
@@ -241,8 +241,8 @@ export function register(server, ctx) {
                         }
                     }
                     catch (err) {
-                        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-                            process.stderr.write(`[phren] import_project backupRestore: ${err instanceof Error ? err.message : String(err)}\n`);
+                        if ((process.env.PHREN_DEBUG))
+                            process.stderr.write(`[phren] import_project backupRestore: ${errorMessage(err)}\n`);
                     }
                 }
                 return mcpResponse({
@@ -261,8 +261,8 @@ export function register(server, ctx) {
                     }
                 }
                 catch (err) {
-                    if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-                        process.stderr.write(`[phren] import_project backupCleanup: ${err instanceof Error ? err.message : String(err)}\n`);
+                    if ((process.env.PHREN_DEBUG))
+                        process.stderr.write(`[phren] import_project backupCleanup: ${errorMessage(err)}\n`);
                 }
             }
             return mcpResponse({
@@ -299,7 +299,7 @@ export function register(server, ctx) {
                 }
                 catch (err) {
                     fs.renameSync(archiveDir, projectDir);
-                    return mcpResponse({ ok: false, error: `Index rebuild failed after archive rename, rolled back: ${err instanceof Error ? err.message : String(err)}` });
+                    return mcpResponse({ ok: false, error: `Index rebuild failed after archive rename, rolled back: ${errorMessage(err)}` });
                 }
                 return mcpResponse({
                     ok: true,
@@ -322,7 +322,7 @@ export function register(server, ctx) {
             }
             catch (err) {
                 fs.renameSync(projectDir, archiveDir);
-                return mcpResponse({ ok: false, error: `Index rebuild failed after unarchive rename, rolled back: ${err instanceof Error ? err.message : String(err)}` });
+                return mcpResponse({ ok: false, error: `Index rebuild failed after unarchive rename, rolled back: ${errorMessage(err)}` });
             }
             return mcpResponse({
                 ok: true,

package/mcp/dist/mcp-extract-facts.js

@@ -24,7 +24,7 @@ export function readExtractedFacts(phrenPath, project) {
         return Array.isArray(data) ? data : [];
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] readExtractedFacts: ${errorMessage(err)}\n`);
         return [];
     }

package/mcp/dist/mcp-extract.js

@@ -1,6 +1,6 @@
 import { mcpResponse } from "./mcp-types.js";
 import { z } from "zod";
-import { isValidProjectName, safeProjectPath } from "./utils.js";
+import { isValidProjectName, safeProjectPath, errorMessage } from "./utils.js";
 import { addFindingsToFile } from "./shared-content.js";
 import { checkOllamaAvailable, checkModelAvailable, generateText, getOllamaUrl, getExtractModel } from "./shared-ollama.js";
 import { debugLog } from "./shared.js";
@@ -34,7 +34,7 @@ function parseFindings(raw) {
         }
     }
     catch (err) {
-        debugLog(`auto_extract: failed to parse LLM output as JSON: ${cleaned.slice(0, 200)} (${err instanceof Error ? err.message : String(err)})`);
+        debugLog(`auto_extract: failed to parse LLM output as JSON: ${cleaned.slice(0, 200)} (${errorMessage(err)})`);
     }
     return [];
 }

package/mcp/dist/mcp-finding.js

@@ -236,7 +236,7 @@ export function register(server, ctx) {
                     extraAnnotationsByFinding.push(conflicts.checked && conflicts.annotations.length > 0 ? conflicts.annotations : []);
                 }
                 catch (err) {
-                    if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                    if ((process.env.PHREN_DEBUG))
                         process.stderr.write(`[phren] add_findings semanticConflict: ${errorMessage(err)}\n`);
                     extraAnnotationsByFinding.push([]);
                 }
@@ -499,7 +499,7 @@ export function register(server, ctx) {
                     hasRemote = remotes.length > 0;
                 }
                 catch (err) {
-                    if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                    if ((process.env.PHREN_DEBUG))
                         process.stderr.write(`[phren] push_changes remoteCheck: ${errorMessage(err)}\n`);
                 }
                 if (!hasRemote) {
@@ -523,7 +523,7 @@ export function register(server, ctx) {
                                 runGit(["pull", "--rebase", "--quiet"], { timeout: 15000 });
                             }
                             catch (pullErr) {
-                                if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                                if ((process.env.PHREN_DEBUG))
                                     process.stderr.write(`[phren] push_changes pullRebase: ${pullErr instanceof Error ? pullErr.message : String(pullErr)}\n`);
                                 const resolved = autoMergeConflicts(phrenPath);
                                 if (resolved) {
@@ -534,13 +534,13 @@ export function register(server, ctx) {
                                         });
                                     }
                                     catch (continueErr) {
-                                        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                                        if ((process.env.PHREN_DEBUG))
                                             process.stderr.write(`[phren] push_changes rebaseContinue: ${continueErr instanceof Error ? continueErr.message : String(continueErr)}\n`);
                                         try {
                                             runGit(["rebase", "--abort"]);
                                         }
                                         catch (abortErr) {
-                                            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                                            if ((process.env.PHREN_DEBUG))
                                                 process.stderr.write(`[phren] push_changes rebaseAbort: ${abortErr instanceof Error ? abortErr.message : String(abortErr)}\n`);
                                         }
                                         break;
@@ -551,7 +551,7 @@ export function register(server, ctx) {
                                         runGit(["rebase", "--abort"]);
                                     }
                                     catch (abortErr) {
-                                        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                                        if ((process.env.PHREN_DEBUG))
                                             process.stderr.write(`[phren] push_changes rebaseAbort2: ${abortErr instanceof Error ? abortErr.message : String(abortErr)}\n`);
                                     }
                                     break;

package/mcp/dist/mcp-graph.js

@@ -2,7 +2,7 @@ import { mcpResponse } from "./mcp-types.js";
 import { z } from "zod";
 import * as fs from "fs";
 import * as crypto from "crypto";
-import { isValidProjectName } from "./utils.js";
+import { isValidProjectName, errorMessage } from "./utils.js";
 import { queryDocBySourceKey, queryRows, queryFragmentLinks, queryCrossProjectFragments, ensureGlobalEntitiesTable, logFragmentMiss } from "./shared-index.js";
 import { runtimeFile } from "./shared.js";
 import { withFileLock } from "./shared-governance.js";
@@ -209,8 +209,8 @@ export function register(server, ctx) {
                 db.run("INSERT OR IGNORE INTO entities (name, type, first_seen_at) VALUES (?, ?, ?)", [fragmentName, resolvedFragmentType, 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] link_findings fragmentInsert: ${err instanceof Error ? err.message : String(err)}\n`);
+                if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG))
+                    process.stderr.write(`[phren] link_findings fragmentInsert: ${errorMessage(err)}\n`);
             }
             const fragmentResult = db.exec("SELECT id FROM entities WHERE name = ? AND type = ?", [fragmentName, resolvedFragmentType]);
             if (!fragmentResult?.length || !fragmentResult[0]?.values?.length) {
@@ -232,8 +232,8 @@ export function register(server, ctx) {
                 db.run("INSERT OR IGNORE INTO entities (name, type, first_seen_at) VALUES (?, ?, ?)", [sourceDoc, "document", 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] link_findings docFragmentInsert: ${err instanceof Error ? err.message : String(err)}\n`);
+                if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG))
+                    process.stderr.write(`[phren] link_findings docFragmentInsert: ${errorMessage(err)}\n`);
             }
             const docFragmentResult = db.exec("SELECT id FROM entities WHERE name = ? AND type = ?", [sourceDoc, "document"]);
             if (!docFragmentResult?.length || !docFragmentResult[0]?.values?.length) {
@@ -245,8 +245,8 @@ export function register(server, ctx) {
                 db.run("INSERT OR IGNORE INTO entity_links (source_id, target_id, rel_type, source_doc) VALUES (?, ?, ?, ?)", [sourceId, targetId, relType, sourceDoc]);
             }
             catch (err) {
-                if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-                    process.stderr.write(`[phren] link_findings linkInsert: ${err instanceof Error ? err.message : String(err)}\n`);
+                if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG))
+                    process.stderr.write(`[phren] link_findings linkInsert: ${errorMessage(err)}\n`);
                 return mcpResponse({ ok: false, error: "Failed to insert fragment link." });
             }
             // 4a. Also populate global_entities so manual links appear in cross_project_fragments
@@ -255,8 +255,8 @@ export function register(server, ctx) {
                 db.run("INSERT OR IGNORE INTO global_entities (entity, project, doc_key) VALUES (?, ?, ?)", [fragmentName, project, sourceDoc]);
             }
             catch (err) {
-                if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-                    process.stderr.write(`[phren] link_findings globalFragments: ${err instanceof Error ? err.message : String(err)}\n`);
+                if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG))
+                    process.stderr.write(`[phren] link_findings globalFragments: ${errorMessage(err)}\n`);
             }
             // 4b. Persist manual link so it survives index rebuilds (mandatory — failure aborts the operation)
             const manualLinksPath = runtimeFile(ctx.phrenPath, "manual-links.json");
@@ -268,8 +268,8 @@ export function register(server, ctx) {
                             existing = JSON.parse(fs.readFileSync(manualLinksPath, "utf8"));
                         }
                         catch (err) {
-                            if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
-                                process.stderr.write(`[phren] link_findings manualLinksRead: ${err instanceof Error ? err.message : String(err)}\n`);
+                            if (process.env.PHREN_DEBUG || (process.env.PHREN_DEBUG))
+                                process.stderr.write(`[phren] link_findings manualLinksRead: ${errorMessage(err)}\n`);
                         }
                     }
                     const newEntry = { entity: fragmentName, entityType: resolvedFragmentType, sourceDoc, relType };