@phren/cli 0.0.17 → 0.0.19

package/mcp/dist/phren-paths.js

@@ -108,7 +108,7 @@ function hasRootManifest(candidate) {
 }
 function hasInstallMarkers(candidate) {
     return fs.existsSync(path.join(candidate, "machines.yaml"))
-        || fs.existsSync(path.join(candidate, ".governance"))
+        || fs.existsSync(path.join(candidate, ".config"))
         || fs.existsSync(path.join(candidate, "global"));
 }
 function isPhrenRootCandidate(candidate) {
@@ -460,7 +460,7 @@ export function computePhrenLiveStateToken(phrenPath) {
         pushDirTokens(parts, path.join(phrenPath, "profiles"));
     }
     pushDirTokens(parts, path.join(phrenPath, "global", "skills"));
-    pushFileToken(parts, path.join(phrenPath, ".governance", "access-control.json"));
+    pushFileToken(parts, path.join(phrenPath, ".config", "access-control.json"));
     pushFileToken(parts, rootManifestPath(phrenPath));
     pushFileToken(parts, runtimeHealthFile(phrenPath));
     pushFileToken(parts, runtimeFile(phrenPath, "audit.log"));

package/mcp/dist/proactivity.js

@@ -20,6 +20,37 @@ function parseProactivityLevel(raw) {
 function resolveProactivityPhrenPath(explicitPhrenPath) {
     return explicitPhrenPath ?? findPhrenPath();
 }
+/** Read per-user preferences from ~/.phren/.users/<actor>/preferences.json. Actor from PHREN_ACTOR env var. */
+export function readUserPreferences(explicitPhrenPath) {
+    const phrenPath = resolveProactivityPhrenPath(explicitPhrenPath);
+    if (!phrenPath)
+        return {};
+    const actor = (process.env.PHREN_ACTOR || "").trim();
+    if (!actor || !/^[a-zA-Z0-9_@.-]{1,128}$/.test(actor))
+        return {};
+    // Sanitize actor name to safe path component (no path traversal)
+    const safeActor = actor.replace(/[^a-zA-Z0-9_@.-]/g, "_");
+    const prefsFile = `${phrenPath}/.users/${safeActor}/preferences.json`;
+    if (!fs.existsSync(prefsFile))
+        return {};
+    try {
+        const parsed = JSON.parse(fs.readFileSync(prefsFile, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        return {
+            proactivity: parseProactivityLevel(parsed.proactivity),
+            proactivityFindings: parseProactivityLevel(parsed.proactivityFindings),
+            proactivityTask: parseProactivityLevel(parsed.proactivityTask),
+            findingSensitivity: ["minimal", "conservative", "balanced", "aggressive"].includes(String(parsed.findingSensitivity))
+                ? parsed.findingSensitivity
+                : undefined,
+        };
+    }
+    catch (err) {
+        debugLog(`readUserPreferences: failed to parse ${prefsFile}: ${errorMessage(err)}`);
+        return {};
+    }
+}
 function readGovernanceProactivityPreferences(explicitPhrenPath) {
     const phrenPath = resolveProactivityPhrenPath(explicitPhrenPath);
     if (!phrenPath)
@@ -41,6 +72,10 @@ function readGovernanceProactivityPreferences(explicitPhrenPath) {
     return {};
 }
 function getConfiguredProactivityDefault(explicitPhrenPath) {
+    // Resolution chain: user prefs (highest) → governance prefs → install prefs → default
+    const userPrefs = readUserPreferences(explicitPhrenPath);
+    if (userPrefs.proactivity)
+        return userPrefs.proactivity;
     const governancePreference = readGovernanceProactivityPreferences(explicitPhrenPath).proactivity;
     if (governancePreference)
         return governancePreference;
@@ -75,6 +110,12 @@ function getWorkflowPolicySensitivityLevel(explicitPhrenPath) {
     }
 }
 function getConfiguredProactivityLevelForFindingsDefault(explicitPhrenPath) {
+    // User prefs take priority over governance prefs
+    const userPrefs = readUserPreferences(explicitPhrenPath);
+    if (userPrefs.proactivityFindings)
+        return userPrefs.proactivityFindings;
+    if (userPrefs.proactivity)
+        return userPrefs.proactivity;
     const prefs = readGovernanceProactivityPreferences(explicitPhrenPath);
     return prefs.proactivityFindings
         ?? prefs.proactivity
@@ -82,6 +123,12 @@ function getConfiguredProactivityLevelForFindingsDefault(explicitPhrenPath) {
         ?? getConfiguredProactivityDefault(explicitPhrenPath);
 }
 function getConfiguredProactivityLevelForTaskDefault(explicitPhrenPath) {
+    // User prefs take priority over governance prefs
+    const userPrefs = readUserPreferences(explicitPhrenPath);
+    if (userPrefs.proactivityTask)
+        return userPrefs.proactivityTask;
+    if (userPrefs.proactivity)
+        return userPrefs.proactivity;
     const prefs = readGovernanceProactivityPreferences(explicitPhrenPath);
     return prefs.proactivityTask
         ?? prefs.proactivity

package/mcp/dist/profile-store.js

@@ -116,6 +116,104 @@ export function setMachineProfile(phrenPath, machine, profile) {
         return phrenOk(`Mapped machine ${machine} -> ${profile}.`);
     });
 }
+const VALID_FINDING_SENSITIVITY_VALS = ["minimal", "conservative", "balanced", "aggressive"];
+const VALID_PROACTIVITY_VALS = ["high", "medium", "low"];
+const VALID_TASK_MODE_VALS = ["off", "manual", "suggest", "auto"];
+const VALID_RISKY_SECTION_VALS = ["Review", "Stale", "Conflicts"];
+function pickEnumVal(value, allowed) {
+    return typeof value === "string" && allowed.includes(value) ? value : undefined;
+}
+function pickFiniteNum(value) {
+    return typeof value === "number" && isFinite(value) ? value : undefined;
+}
+function parseProfilePolicyDefaults(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return undefined;
+    const data = raw;
+    const retentionRaw = data.retentionPolicy && typeof data.retentionPolicy === "object" && !Array.isArray(data.retentionPolicy)
+        ? data.retentionPolicy
+        : undefined;
+    const decayRaw = retentionRaw?.decay && typeof retentionRaw.decay === "object" && !Array.isArray(retentionRaw.decay)
+        ? retentionRaw.decay
+        : undefined;
+    const workflowRaw = data.workflowPolicy && typeof data.workflowPolicy === "object" && !Array.isArray(data.workflowPolicy)
+        ? data.workflowPolicy
+        : undefined;
+    const result = {};
+    const fs_ = pickEnumVal(data.findingSensitivity, VALID_FINDING_SENSITIVITY_VALS);
+    if (fs_)
+        result.findingSensitivity = fs_;
+    const pr = pickEnumVal(data.proactivity, VALID_PROACTIVITY_VALS);
+    if (pr)
+        result.proactivity = pr;
+    const prf = pickEnumVal(data.proactivityFindings, VALID_PROACTIVITY_VALS);
+    if (prf)
+        result.proactivityFindings = prf;
+    const prt = pickEnumVal(data.proactivityTask, VALID_PROACTIVITY_VALS);
+    if (prt)
+        result.proactivityTask = prt;
+    const tm = pickEnumVal(data.taskMode, VALID_TASK_MODE_VALS);
+    if (tm)
+        result.taskMode = tm;
+    if (retentionRaw) {
+        const ret = {};
+        const ttlDays = pickFiniteNum(retentionRaw.ttlDays);
+        if (ttlDays !== undefined)
+            ret.ttlDays = ttlDays;
+        const retentionDays = pickFiniteNum(retentionRaw.retentionDays);
+        if (retentionDays !== undefined)
+            ret.retentionDays = retentionDays;
+        const aat = pickFiniteNum(retentionRaw.autoAcceptThreshold);
+        if (aat !== undefined)
+            ret.autoAcceptThreshold = aat;
+        const mic = pickFiniteNum(retentionRaw.minInjectConfidence);
+        if (mic !== undefined)
+            ret.minInjectConfidence = mic;
+        if (decayRaw) {
+            const decay = {};
+            const d30 = pickFiniteNum(decayRaw.d30);
+            if (d30 !== undefined)
+                decay.d30 = d30;
+            const d60 = pickFiniteNum(decayRaw.d60);
+            if (d60 !== undefined)
+                decay.d60 = d60;
+            const d90 = pickFiniteNum(decayRaw.d90);
+            if (d90 !== undefined)
+                decay.d90 = d90;
+            const d120 = pickFiniteNum(decayRaw.d120);
+            if (d120 !== undefined)
+                decay.d120 = d120;
+            if (Object.keys(decay).length > 0)
+                ret.decay = decay;
+        }
+        if (Object.keys(ret).length > 0)
+            result.retentionPolicy = ret;
+    }
+    if (workflowRaw) {
+        const wf = {};
+        const lct = pickFiniteNum(workflowRaw.lowConfidenceThreshold);
+        if (lct !== undefined)
+            wf.lowConfidenceThreshold = lct;
+        if (Array.isArray(workflowRaw.riskySections)) {
+            const rs = workflowRaw.riskySections
+                .filter((s) => typeof s === "string" && VALID_RISKY_SECTION_VALS.includes(s));
+            if (rs.length > 0)
+                wf.riskySections = rs;
+        }
+        if (Object.keys(wf).length > 0)
+            result.workflowPolicy = wf;
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+export function getActiveProfileDefaults(phrenPath, profile) {
+    const profiles = listProfiles(phrenPath);
+    if (!profiles.ok)
+        return undefined;
+    const activeName = profile ?? profiles.data[0]?.name;
+    if (!activeName)
+        return undefined;
+    return profiles.data.find((p) => p.name === activeName)?.defaults;
+}
 export function listProfiles(phrenPath) {
     const profilesDir = path.join(phrenPath, "profiles");
     if (!fs.existsSync(profilesDir))
@@ -136,7 +234,8 @@ export function listProfiles(phrenPath) {
             const projects = Array.isArray(data?.projects)
                 ? data.projects.map((project) => String(project)).filter(Boolean)
                 : [];
-            profiles.push({ name, file: full, projects });
+            const defaults = parseProfilePolicyDefaults(data?.defaults);
+            profiles.push({ name, file: full, projects, ...(defaults ? { defaults } : {}) });
         }
         catch (err) {
             if ((process.env.PHREN_DEBUG))

package/mcp/dist/shared-index.js

@@ -303,7 +303,7 @@ function computePhrenHash(phrenPath, profile, preGlobbed) {
                 process.stderr.write(`[phren] computePhrenHash skip: ${errorMessage(err)}\n`);
         }
     }
-    const indexPolicyPath = path.join(phrenPath, ".governance", "index-policy.json");
+    const indexPolicyPath = path.join(phrenPath, ".config", "index-policy.json");
     if (fs.existsSync(indexPolicyPath)) {
         try {
             const stat = fs.statSync(indexPolicyPath);
@@ -683,7 +683,7 @@ function isSentinelFresh(phrenPath, sentinel) {
     // Check mtime of key directories — if any are newer than the sentinel, it's stale
     const dirsToCheck = [
         phrenPath,
-        path.join(phrenPath, ".governance"),
+        path.join(phrenPath, ".config"),
         path.join(phrenPath, ".runtime"),
     ];
     for (const dir of dirsToCheck) {

package/mcp/dist/shared-retrieval.js

@@ -1,6 +1,6 @@
 // shared-retrieval.ts — shared retrieval core used by hooks and MCP search.
 import { getQualityMultiplier, entryScoreKey, } from "./shared-governance.js";
-import { queryDocRows, queryRows, cosineFallback, extractSnippet, getDocSourceKey, getEntityBoostDocs, decodeFiniteNumber, rowToDocWithRowid, } from "./shared-index.js";
+import { queryDocRows, queryRows, cosineFallback, extractSnippet, getDocSourceKey, getEntityBoostDocs, decodeFiniteNumber, rowToDocWithRowid, buildIndex, } from "./shared-index.js";
 import { filterTrustedFindingsDetailed, } from "./shared-content.js";
 import { parseCitationComment } from "./content-citation.js";
 import { getHighImpactFindings } from "./finding-impact.js";
@@ -490,6 +490,47 @@ export async function searchKnowledgeRows(db, options) {
     }
     return { safeQuery, rows, usedFallback };
 }
+/**
+ * Parse PHREN_FEDERATION_PATHS env var and return valid, distinct paths.
+ * Paths are colon-separated. The local phrenPath is excluded to avoid duplicate results.
+ */
+export function parseFederationPaths(localPhrenPath) {
+    const raw = process.env.PHREN_FEDERATION_PATHS ?? "";
+    if (!raw.trim())
+        return [];
+    return raw
+        .split(":")
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0 && p !== localPhrenPath && fs.existsSync(p));
+}
+/**
+ * Search additional phren stores defined in PHREN_FEDERATION_PATHS.
+ * Returns an array of results tagged with their source store. Read-only — no mutations.
+ */
+export async function searchFederatedStores(localPhrenPath, options) {
+    const federationPaths = parseFederationPaths(localPhrenPath);
+    if (federationPaths.length === 0)
+        return [];
+    const allRows = [];
+    for (const storePath of federationPaths) {
+        try {
+            const federatedDb = await buildIndex(storePath);
+            const result = await searchKnowledgeRows(federatedDb, { ...options, phrenPath: storePath });
+            if (result.rows && result.rows.length > 0) {
+                for (const row of result.rows) {
+                    allRows.push({ ...row, federationSource: storePath });
+                }
+            }
+        }
+        catch (err) {
+            if (process.env.PHREN_DEBUG) {
+                process.stderr.write(`[phren] federatedSearch storePath=${storePath}: ${errorMessage(err)}\n`);
+            }
+            // Federation errors are non-fatal — continue with other stores
+        }
+    }
+    return allRows;
+}
 // ── Trust filter ─────────────────────────────────────────────────────────────
 const TRUST_FILTERED_TYPES = new Set(["findings", "reference", "knowledge"]);
 /** Apply trust filter to rows. Returns filtered rows plus any queue/audit items to be written

package/mcp/dist/shell-input.js

@@ -383,7 +383,7 @@ export async function executePalette(host, input) {
                     process.stderr.write(`[phren] shell status gitStatus: ${errorMessage(err)}\n`);
             }
             const auditPathNew = runtimeFile(host.phrenPath, "audit.log");
-            const auditPathLegacy = path.join(host.phrenPath, ".governance", "audit.log");
+            const auditPathLegacy = path.join(host.phrenPath, ".config", "audit.log");
             const auditPath = fs.existsSync(auditPathNew) ? auditPathNew : auditPathLegacy;
             if (fs.existsSync(auditPath)) {
                 const auditLines = fs.readFileSync(auditPath, "utf8").split("\n")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phren/cli",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Knowledge layer for AI agents. Phren learns and recalls.",
   "type": "module",
   "bin": {