@phren/cli 0.0.10 → 0.0.11

package/mcp/dist/link.js

@@ -1,17 +1,17 @@
 import * as fs from "fs";
 import * as path from "path";
-import * as crypto from "crypto";
 import * as readline from "readline";
 import * as yaml from "js-yaml";
 import { execFileSync } from "child_process";
-import { fileURLToPath } from "url";
+import { ROOT } from "./package-metadata.js";
 import { configureClaude, configureCodexMcp, configureCopilotMcp, configureCursorMcp, configureVSCode, ensureGovernanceFiles, getHooksEnabledPreference, getMcpEnabledPreference, isVersionNewer, logMcpTargetStatus, patchJsonFile, setMcpEnabledPreference, } from "./init.js";
 import { configureAllHooks, detectInstalledTools } from "./hooks.js";
 import { getMachineName, persistMachineName } from "./machine-identity.js";
-import { debugLog, EXEC_TIMEOUT_MS, EXEC_TIMEOUT_QUICK_MS, isRecord, homePath, hookConfigPath, installPreferencesFile, } from "./shared.js";
+import { debugLog, EXEC_TIMEOUT_MS, EXEC_TIMEOUT_QUICK_MS, isRecord, homePath, hookConfigPath, installPreferencesFile, atomicWriteText, } from "./shared.js";
 import { errorMessage } from "./utils.js";
+import { log } from "./init-shared.js";
 import { listMachines as listMachinesShared, listProfiles as listProfilesShared, setMachineProfile, } from "./profile-store.js";
-import { writeSkillMd } from "./link-skills.js";
+import { writeSkillMd, isManagedSymlink } from "./link-skills.js";
 import { syncScopeSkillsToDir } from "./skill-files.js";
 import { renderSkillInstructionsSection } from "./skill-registry.js";
 import { findProjectDir } from "./project-locator.js";
@@ -23,14 +23,6 @@ export { updateFileChecksums, verifyFileChecksums } from "./link-checksums.js";
 export { findProjectDir } from "./project-locator.js";
 export { parseSkillFrontmatter, validateSkillFrontmatter, validateSkillsDir, readSkillManifestHooks, } from "./link-skills.js";
 // ── Helpers (exported for link-doctor) ──────────────────────────────────────
-const ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
-function log(msg) { process.stdout.write(msg + "\n"); }
-function atomicWriteText(filePath, content) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    const tmpPath = `${filePath}.tmp-${crypto.randomUUID()}`;
-    fs.writeFileSync(tmpPath, content);
-    fs.renameSync(tmpPath, filePath);
-}
 export { getMachineName } from "./machine-identity.js";
 export function lookupProfile(phrenPath, machine) {
     const listed = listMachinesShared(phrenPath);
@@ -123,7 +115,7 @@ function setupSparseCheckout(phrenPath, projects) {
         execFileSync("git", ["rev-parse", "--git-dir"], { cwd: phrenPath, stdio: "ignore", timeout: EXEC_TIMEOUT_QUICK_MS });
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] setupSparseCheckout notAGitRepo: ${errorMessage(err)}\n`);
         return;
     }
@@ -184,10 +176,9 @@ function symlinkFile(src, dest, managedRoot) {
         if (stat.isSymbolicLink()) {
             const currentTarget = fs.readlinkSync(dest);
             const resolvedTarget = path.resolve(path.dirname(dest), currentTarget);
-            const managedPrefix = path.resolve(managedRoot) + path.sep;
             if (resolvedTarget === path.resolve(src))
                 return true;
-            if (!resolvedTarget.startsWith(managedPrefix)) {
+            if (!isManagedSymlink(dest, managedRoot)) {
                 log(`  preserve existing symlink: ${dest}`);
                 return false;
             }
@@ -238,8 +229,7 @@ function writeManagedAgentsFile(src, dest, content, managedRoot) {
         if (stat.isSymbolicLink()) {
             const currentTarget = fs.readlinkSync(dest);
             const resolvedTarget = path.resolve(path.dirname(dest), currentTarget);
-            const managedPrefix = path.resolve(managedRoot) + path.sep;
-            if (resolvedTarget === path.resolve(src) || resolvedTarget.startsWith(managedPrefix)) {
+            if (resolvedTarget === path.resolve(src) || isManagedSymlink(dest, managedRoot)) {
                 fs.unlinkSync(dest);
             }
             else {
@@ -278,7 +268,7 @@ function linkGlobal(phrenPath, tools) {
                 symlinkFile(globalClaude, path.join(copilotInstrDir, "copilot-instructions.md"), phrenPath);
             }
             catch (err) {
-                if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                if ((process.env.PHREN_DEBUG))
                     process.stderr.write(`[phren] linkGlobal copilotInstructions: ${errorMessage(err)}\n`);
             }
         }
@@ -324,7 +314,7 @@ function linkProject(phrenPath, project, tools) {
                         symlinkFile(src, path.join(copilotDir, "copilot-instructions.md"), phrenPath);
                     }
                     catch (err) {
-                        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                        if ((process.env.PHREN_DEBUG))
                             process.stderr.write(`[phren] linkProject copilotInstructions: ${errorMessage(err)}\n`);
                     }
                 }
@@ -348,7 +338,7 @@ function linkProject(phrenPath, project, tools) {
             addTokenAnnotation(claudeFile);
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            if ((process.env.PHREN_DEBUG))
                 process.stderr.write(`[phren] linkProject tokenAnnotation: ${errorMessage(err)}\n`);
         }
     }
@@ -365,7 +355,7 @@ function linkProject(phrenPath, project, tools) {
                 excludeEntries.push("AGENTS.md");
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            if ((process.env.PHREN_DEBUG))
                 process.stderr.write(`[phren] linkProject agentsMd: ${errorMessage(err)}\n`);
         }
     }
@@ -506,7 +496,7 @@ export async function runLink(phrenPath, opts = {}) {
         mcpStatus = configureClaude(phrenPath, { mcpEnabled, hooksEnabled }) ?? "installed";
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] link configureClaude: ${errorMessage(err)}\n`);
     }
     logMcpTargetStatus("Claude", mcpStatus);
@@ -515,7 +505,7 @@ export async function runLink(phrenPath, opts = {}) {
         vsStatus = configureVSCode(phrenPath, { mcpEnabled }) ?? "no_vscode";
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] link configureVSCode: ${errorMessage(err)}\n`);
     }
     logMcpTargetStatus("VS Code", vsStatus);
@@ -524,7 +514,7 @@ export async function runLink(phrenPath, opts = {}) {
         cursorStatus = configureCursorMcp(phrenPath, { mcpEnabled }) ?? "no_cursor";
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] link configureCursorMcp: ${errorMessage(err)}\n`);
     }
     logMcpTargetStatus("Cursor", cursorStatus);
@@ -533,7 +523,7 @@ export async function runLink(phrenPath, opts = {}) {
         copilotStatus = configureCopilotMcp(phrenPath, { mcpEnabled }) ?? "no_copilot";
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] link configureCopilotMcp: ${errorMessage(err)}\n`);
     }
     logMcpTargetStatus("Copilot CLI", copilotStatus);
@@ -542,7 +532,7 @@ export async function runLink(phrenPath, opts = {}) {
         codexStatus = configureCodexMcp(phrenPath, { mcpEnabled }) ?? "no_codex";
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] link configureCodexMcp: ${errorMessage(err)}\n`);
     }
     logMcpTargetStatus("Codex", codexStatus);
@@ -566,7 +556,7 @@ export async function runLink(phrenPath, opts = {}) {
         log(`  phren.SKILL.md written (agentskills-compatible tools)`);
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+        if ((process.env.PHREN_DEBUG))
             process.stderr.write(`[phren] link writeSkillMd: ${errorMessage(err)}\n`);
     }
     log("");

package/mcp/dist/machine-identity.js

@@ -1,17 +1,9 @@
 import * as fs from "fs";
 import * as os from "os";
-import * as path from "path";
-import * as crypto from "crypto";
-import { homePath } from "./shared.js";
+import { homePath, atomicWriteText } from "./shared.js";
 function phrenMachineFilePath() {
     return homePath(".phren", ".machine-id");
 }
-function atomicWriteText(filePath, content) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    const tmpPath = `${filePath}.tmp-${crypto.randomUUID()}`;
-    fs.writeFileSync(tmpPath, content);
-    fs.renameSync(tmpPath, filePath);
-}
 export function machineFilePath() {
     return phrenMachineFilePath();
 }

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 [];
 }