@phren/cli 0.0.28 → 0.0.32

package/mcp/dist/telemetry.js

@@ -2,6 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { runtimeDir } from "./shared.js";
 import { errorMessage } from "./utils.js";
+import { logger } from "./logger.js";
 // In-memory buffers keyed by phrenPath to batch disk writes
 // Keeping per-path buffers avoids silently losing events when the active path changes.
 const buffers = new Map();
@@ -26,8 +27,7 @@ function loadFromDisk(phrenPath) {
         };
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG))
-            process.stderr.write(`[phren] telemetry loadFromDisk: ${errorMessage(err)}\n`);
+        logger.debug("telemetry loadFromDisk", errorMessage(err));
         return defaults;
     }
 }
@@ -58,8 +58,7 @@ function flushTelemetryForPath(phrenPath) {
         fs.writeFileSync(file, JSON.stringify(data, null, 2) + "\n");
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG))
-            process.stderr.write(`[phren] telemetry flush: ${errorMessage(err)}\n`);
+        logger.debug("telemetry flush", errorMessage(err));
     }
     pendingCounts.set(phrenPath, 0);
 }

package/mcp/dist/tool-registry.js

@@ -2,18 +2,18 @@ import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
 const CATEGORY_BY_MODULE = {
-    "mcp-search": "Search and browse",
-    "mcp-tasks": "Task management",
-    "mcp-finding": "Finding capture",
-    "mcp-memory": "Memory quality",
-    "mcp-data": "Data management",
-    "mcp-graph": "Fragments and graph",
-    "mcp-session": "Session management",
-    "mcp-ops": "Operations and review",
-    "mcp-skills": "Skills management",
-    "mcp-hooks": "Hooks management",
-    "mcp-config": "Configuration",
-    "mcp-extract": "Extraction",
+    "search": "Search and browse",
+    "tasks": "Task management",
+    "finding": "Finding capture",
+    "memory": "Memory quality",
+    "data": "Data management",
+    "graph": "Fragments and graph",
+    "session": "Session management",
+    "ops": "Operations and review",
+    "skills": "Skills management",
+    "hooks": "Hooks management",
+    "config": "Configuration",
+    "extract": "Extraction",
 };
 const MODULE_ORDER = Object.keys(CATEGORY_BY_MODULE);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -45,7 +45,7 @@ function parseModuleTools(moduleName, source) {
         });
     }
     // Handle loop-registered tools: { tool: "name", ... } patterns followed by registerTool(action.tool, ...)
-    const loopPattern = /for\s*\(const\s+(\w+)\s+of\s+\[([\s\S]*?)\]\s*(?:as\s+const\s*)?\)\s*\{\s*server\.registerTool\(\s*\1\.tool\s*,\s*\{([\s\S]*?)\}\s*,/g;
+    const loopPattern = /for\s*\(const\s+(\w+)\s+of\s+\[([\s\S]*?)\]\s*(?:as\s+const\s*)?\)\s*\{[\s\S]*?server\.registerTool\(\s*\1\.tool\s*,\s*\{([\s\S]*?)\}\s*,/g;
     for (const loopMatch of source.matchAll(loopPattern)) {
         const [, , itemsBlock, configBlock] = loopMatch;
         const itemPattern = /\{\s*tool:\s*"([^"]+)"[^}]*verb:\s*"([^"]+)"/g;
@@ -66,11 +66,23 @@ function parseModuleTools(moduleName, source) {
 export function getRegisteredTools() {
     const dir = sourceDir();
     const entries = [];
+    const toolsDir = path.join(dir, "tools");
     for (const moduleName of MODULE_ORDER) {
-        const tsPath = path.join(dir, `${moduleName}.ts`);
-        const jsPath = path.join(dir, `${moduleName}.js`);
-        const sourcePath = fs.existsSync(tsPath) ? tsPath : jsPath;
-        if (!fs.existsSync(sourcePath))
+        // Tool files may live in the tools/ subdirectory or alongside tool-registry.ts
+        let sourcePath;
+        for (const base of [toolsDir, dir]) {
+            const tsPath = path.join(base, `${moduleName}.ts`);
+            const jsPath = path.join(base, `${moduleName}.js`);
+            if (fs.existsSync(tsPath)) {
+                sourcePath = tsPath;
+                break;
+            }
+            if (fs.existsSync(jsPath)) {
+                sourcePath = jsPath;
+                break;
+            }
+        }
+        if (!sourcePath)
             continue;
         entries.push(...parseModuleTools(moduleName, fs.readFileSync(sourcePath, "utf8")));
     }

package/mcp/dist/tools/config.js

@@ -0,0 +1,515 @@
+import * as fs from "fs";
+import * as path from "path";
+import { mcpResponse } from "./types.js";
+import { z } from "zod";
+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, safeProjectPath } from "../utils.js";
+import { readProjectTopics, writeProjectTopics, } from "../project-topics.js";
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function proactivitySnapshot(phrenPath) {
+    const snap = buildProactivitySnapshot(phrenPath);
+    return { configured: snap.configured, effective: snap.effective };
+}
+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 .config/.");
+// ── Topic helpers (shared by get_config topic domain and set_config topic domain) ──
+function getTopicConfigData(phrenPath, project) {
+    const projectDir = safeProjectPath(phrenPath, project);
+    if (!projectDir || !fs.existsSync(projectDir)) {
+        return { ok: false, error: `Project "${project}" not found in phren.` };
+    }
+    const result = readProjectTopics(phrenPath, project);
+    const configPath = path.join(projectDir, "topic-config.json");
+    const raw = fs.existsSync(configPath)
+        ? (() => { try {
+            return JSON.parse(fs.readFileSync(configPath, "utf8"));
+        }
+        catch {
+            return null;
+        } })()
+        : null;
+    return {
+        ok: true,
+        data: {
+            project,
+            source: result.source,
+            domain: result.domain ?? raw?.domain ?? null,
+            topics: result.topics,
+            pinnedTopics: raw?.pinnedTopics ?? [],
+        },
+    };
+}
+// ── Registration ────────────────────────────────────────────────────────────
+export function register(server, ctx) {
+    const { phrenPath } = ctx;
+    // ── get_config ────────────────────────────────────────────────────────────
+    server.registerTool("get_config", {
+        title: "◆ phren · get config",
+        description: "Read current configuration for one or all config domains: proactivity, taskMode, " +
+            "findingSensitivity, retention (policy), workflow, access, index, topic. " +
+            "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", "topic", "all"])
+                .optional()
+                .describe("Config domain to read. Defaults to 'all'."),
+            project: projectParam,
+        }),
+    }, async ({ domain, project }) => {
+        const d = domain ?? "all";
+        // topic domain requires a project
+        if (d === "topic") {
+            if (!project) {
+                return mcpResponse({ ok: false, error: "The 'topic' domain requires a project parameter." });
+            }
+            const err = validateProject(project);
+            if (err)
+                return mcpResponse({ ok: false, error: err });
+            const topicResult = getTopicConfigData(phrenPath, project);
+            if (!topicResult.ok)
+                return mcpResponse({ ok: false, error: topicResult.error });
+            return mcpResponse({
+                ok: true,
+                message: `Topic config for "${project}" (source: ${topicResult.data.source}).`,
+                data: topicResult.data,
+            });
+        }
+        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);
+        }
+        if (d === "all" || d === "taskMode") {
+            const wf = getWorkflowPolicy(phrenPath);
+            result.taskMode = { taskMode: wf.taskMode };
+        }
+        if (d === "all" || d === "findingSensitivity") {
+            const wf = getWorkflowPolicy(phrenPath);
+            const level = wf.findingSensitivity;
+            const config = FINDING_SENSITIVITY_CONFIG[level];
+            result.findingSensitivity = { level, ...config };
+        }
+        if (d === "all" || d === "retention") {
+            result.retention = getRetentionPolicy(phrenPath);
+        }
+        if (d === "all" || d === "workflow") {
+            result.workflow = getWorkflowPolicy(phrenPath);
+        }
+        if (d === "all" || d === "index") {
+            result.index = getIndexPolicy(phrenPath);
+        }
+        return mcpResponse({
+            ok: true,
+            message: `Config for ${d === "all" ? "all domains" : d}.`,
+            data: result,
+        });
+    });
+    // ── set_config ──────────────────────────────────────────────────────────
+    server.registerTool("set_config", {
+        title: "◆ phren · set config",
+        description: "Update configuration for a specific domain. Replaces set_proactivity, set_task_mode, " +
+            "set_finding_sensitivity, set_retention_policy, set_workflow_policy, set_index_policy, " +
+            "and set_topic_config. When project is provided, writes to that project's phren.project.yaml " +
+            "instead of global .config/.",
+        inputSchema: z.object({
+            domain: z.enum(["proactivity", "taskMode", "findingSensitivity", "retention", "workflow", "index", "topic"]),
+            settings: z.record(z.string(), z.unknown()).describe("Domain-specific settings. proactivity: { level, scope? } | taskMode: { mode } | " +
+                "findingSensitivity: { level } | retention: { ttlDays?, retentionDays?, autoAcceptThreshold?, " +
+                "minInjectConfidence?, decay? } | workflow: { lowConfidenceThreshold?, riskySections?, taskMode?, " +
+                "findingSensitivity? } | index: { includeGlobs?, excludeGlobs?, includeHidden? } | " +
+                "topic: { topics, domain? }"),
+            project: z.string().optional().describe("Project name. When provided, writes to that project's phren.project.yaml instead of global .config/. " +
+                "Required for the 'topic' domain."),
+        }),
+    }, async ({ domain, settings, project }) => {
+        switch (domain) {
+            // ── proactivity ───────────────────────────────────────────────
+            case "proactivity": {
+                const level = settings.level;
+                if (!level || !PROACTIVITY_LEVELS.includes(level)) {
+                    return mcpResponse({ ok: false, error: `Invalid proactivity level. Must be one of: ${PROACTIVITY_LEVELS.join(", ")}.` });
+                }
+                const scope = settings.scope ?? "base";
+                if (!["base", "findings", "tasks"].includes(scope)) {
+                    return mcpResponse({ ok: false, error: `Invalid scope. Must be one of: base, findings, tasks.` });
+                }
+                const s = scope;
+                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;
+                else if (s === "findings")
+                    patch.proactivityFindings = level;
+                else if (s === "tasks")
+                    patch.proactivityTask = level;
+                writeGovernanceInstallPreferences(phrenPath, patch);
+                return mcpResponse({
+                    ok: true,
+                    message: `Proactivity ${s} set to ${level}.`,
+                    data: proactivitySnapshot(phrenPath),
+                });
+            }
+            // ── taskMode ──────────────────────────────────────────────────
+            case "taskMode": {
+                const mode = settings.mode;
+                if (!mode || !VALID_TASK_MODES.includes(mode)) {
+                    return mcpResponse({ ok: false, error: `Invalid task mode. Must be one of: ${VALID_TASK_MODES.join(", ")}.` });
+                }
+                const validMode = mode;
+                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: validMode,
+                    }));
+                    return mcpResponse({
+                        ok: true,
+                        message: warning
+                            ? `Task mode set to ${validMode} for project "${project}". WARNING: ${warning}`
+                            : `Task mode set to ${validMode} for project "${project}".`,
+                        data: { project, taskMode: validMode, ...(warning ? { warning } : {}) },
+                    });
+                }
+                const result = updateWorkflowPolicy(phrenPath, { taskMode: validMode });
+                if (!result.ok) {
+                    return mcpResponse({ ok: false, error: result.error, errorCode: result.code });
+                }
+                return mcpResponse({
+                    ok: true,
+                    message: `Task mode set to ${validMode}.`,
+                    data: { taskMode: validMode },
+                });
+            }
+            // ── findingSensitivity ────────────────────────────────────────
+            case "findingSensitivity": {
+                const level = settings.level;
+                if (!level || !VALID_FINDING_SENSITIVITY.includes(level)) {
+                    return mcpResponse({ ok: false, error: `Invalid finding sensitivity. Must be one of: ${VALID_FINDING_SENSITIVITY.join(", ")}.` });
+                }
+                const validLevel = level;
+                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: validLevel,
+                    }));
+                    const config = FINDING_SENSITIVITY_CONFIG[validLevel];
+                    return mcpResponse({
+                        ok: true,
+                        message: warning
+                            ? `Finding sensitivity set to ${validLevel} for project "${project}". WARNING: ${warning}`
+                            : `Finding sensitivity set to ${validLevel} for project "${project}".`,
+                        data: { project, level: validLevel, ...config, ...(warning ? { warning } : {}) },
+                    });
+                }
+                const result = updateWorkflowPolicy(phrenPath, { findingSensitivity: validLevel });
+                if (!result.ok) {
+                    return mcpResponse({ ok: false, error: result.error, errorCode: result.code });
+                }
+                const config = FINDING_SENSITIVITY_CONFIG[validLevel];
+                return mcpResponse({
+                    ok: true,
+                    message: `Finding sensitivity set to ${validLevel}.`,
+                    data: { level: validLevel, ...config },
+                });
+            }
+            // ── retention ─────────────────────────────────────────────────
+            case "retention": {
+                const { ttlDays, retentionDays, autoAcceptThreshold, minInjectConfidence, decay } = settings;
+                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)
+                    globalPatch.ttlDays = ttlDays;
+                if (retentionDays !== undefined)
+                    globalPatch.retentionDays = retentionDays;
+                if (autoAcceptThreshold !== undefined)
+                    globalPatch.autoAcceptThreshold = autoAcceptThreshold;
+                if (minInjectConfidence !== undefined)
+                    globalPatch.minInjectConfidence = minInjectConfidence;
+                if (decay !== undefined)
+                    globalPatch.decay = decay;
+                const result = updateRetentionPolicy(phrenPath, globalPatch);
+                if (!result.ok) {
+                    return mcpResponse({ ok: false, error: result.error, errorCode: result.code });
+                }
+                return mcpResponse({
+                    ok: true,
+                    message: "Retention policy updated.",
+                    data: result.data,
+                });
+            }
+            // ── workflow ──────────────────────────────────────────────────
+            case "workflow": {
+                const { lowConfidenceThreshold, riskySections, taskMode, findingSensitivity } = settings;
+                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: 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;
+                if (riskySections !== undefined)
+                    patch.riskySections = riskySections;
+                if (taskMode !== undefined)
+                    patch.taskMode = taskMode;
+                if (findingSensitivity !== undefined)
+                    patch.findingSensitivity = findingSensitivity;
+                const result = updateWorkflowPolicy(phrenPath, patch);
+                if (!result.ok) {
+                    return mcpResponse({ ok: false, error: result.error, errorCode: result.code });
+                }
+                return mcpResponse({
+                    ok: true,
+                    message: "Workflow policy updated.",
+                    data: result.data,
+                });
+            }
+            // ── index ─────────────────────────────────────────────────────
+            case "index": {
+                const { includeGlobs, excludeGlobs, includeHidden } = settings;
+                const patch = {};
+                if (includeGlobs !== undefined)
+                    patch.includeGlobs = includeGlobs;
+                if (excludeGlobs !== undefined)
+                    patch.excludeGlobs = excludeGlobs;
+                if (includeHidden !== undefined)
+                    patch.includeHidden = includeHidden;
+                const result = updateIndexPolicy(phrenPath, patch);
+                if (!result.ok) {
+                    return mcpResponse({ ok: false, error: result.error, errorCode: result.code });
+                }
+                return mcpResponse({
+                    ok: true,
+                    message: "Index policy updated.",
+                    data: result.data,
+                });
+            }
+            // ── topic ─────────────────────────────────────────────────────
+            case "topic": {
+                if (!project) {
+                    return mcpResponse({ ok: false, error: "The 'topic' domain requires a project parameter." });
+                }
+                const err = validateProject(project);
+                if (err)
+                    return mcpResponse({ ok: false, error: err });
+                const projectDir = safeProjectPath(phrenPath, project);
+                if (!projectDir || !fs.existsSync(projectDir)) {
+                    return mcpResponse({ ok: false, error: `Project "${project}" not found in phren.` });
+                }
+                const topics = settings.topics;
+                if (!topics || !Array.isArray(topics)) {
+                    return mcpResponse({ ok: false, error: "The 'topic' domain requires a 'topics' array in settings." });
+                }
+                const topicDomain = settings.domain;
+                const normalized = topics.map((t) => ({
+                    slug: t.slug,
+                    label: t.label,
+                    description: t.description ?? "",
+                    keywords: t.keywords ?? [],
+                }));
+                // If a domain is provided, patch it onto the existing file before writing topics
+                if (topicDomain) {
+                    const configPath = path.join(projectDir, "topic-config.json");
+                    if (fs.existsSync(configPath)) {
+                        try {
+                            const existing = JSON.parse(fs.readFileSync(configPath, "utf8"));
+                            if (existing && typeof existing === "object") {
+                                existing.domain = topicDomain;
+                                fs.writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n");
+                            }
+                        }
+                        catch {
+                            // ignore read errors; writeProjectTopics will still succeed
+                        }
+                    }
+                    else {
+                        fs.mkdirSync(projectDir, { recursive: true });
+                        fs.writeFileSync(configPath, JSON.stringify({ version: 1, domain: topicDomain, topics: [] }, null, 2) + "\n");
+                    }
+                }
+                const result = writeProjectTopics(phrenPath, project, normalized);
+                if (!result.ok) {
+                    return mcpResponse({ ok: false, error: result.error });
+                }
+                return mcpResponse({
+                    ok: true,
+                    message: `Topic config written for "${project}" (${result.topics.length} topics).`,
+                    data: { project, topics: result.topics, domain: topicDomain ?? null },
+                });
+            }
+            default:
+                return mcpResponse({ ok: false, error: `Unknown config domain: ${domain}` });
+        }
+    });
+}

package/mcp/dist/{mcp-data.js → tools/data.js}

@@ -1,10 +1,11 @@
-import { mcpResponse } from "./mcp-types.js";
+import { mcpResponse } from "./types.js";
 import { z } from "zod";
 import * as fs from "fs";
 import * as path from "path";
-import { isValidProjectName, errorMessage, safeProjectPath } from "./utils.js";
-import { readFindings, readTasks, resolveTaskFilePath, TASKS_FILENAME } from "./data-access.js";
-import { debugLog, findArchivedProjectNameCaseInsensitive, findProjectNameCaseInsensitive, normalizeProjectNameForCreate } from "./shared.js";
+import { isValidProjectName, errorMessage, safeProjectPath } from "../utils.js";
+import { readFindings, readTasks, resolveTaskFilePath, TASKS_FILENAME } from "../data/access.js";
+import { debugLog, findArchivedProjectNameCaseInsensitive, findProjectNameCaseInsensitive, normalizeProjectNameForCreate } from "../shared.js";
+import { logger } from "../logger.js";
 const importPayloadSchema = z.object({
     project: z.string(),
     overwrite: z.boolean().optional(),
@@ -77,8 +78,7 @@ export function register(server, ctx) {
                 decoded = JSON.parse(rawData);
             }
             catch (err) {
-                if ((process.env.PHREN_DEBUG))
-                    process.stderr.write(`[phren] import_project jsonParse: ${errorMessage(err)}\n`);
+                logger.debug("data", `import_project jsonParse: ${errorMessage(err)}`);
                 return mcpResponse({ ok: false, error: "Invalid JSON input." });
             }
             const parsedResult = importPayloadSchema.safeParse(decoded);
@@ -237,8 +237,7 @@ export function register(server, ctx) {
                         }
                     }
                     catch (err) {
-                        if ((process.env.PHREN_DEBUG))
-                            process.stderr.write(`[phren] import_project backupRestore: ${errorMessage(err)}\n`);
+                        logger.debug("data", `import_project backupRestore: ${errorMessage(err)}`);
                     }
                 }
                 return mcpResponse({
@@ -253,8 +252,7 @@ export function register(server, ctx) {
                     fs.rmSync(backupDir, { recursive: true, force: true });
                 }
                 catch (err) {
-                    if ((process.env.PHREN_DEBUG))
-                        process.stderr.write(`[phren] import_project backupCleanup: ${errorMessage(err)}\n`);
+                    logger.debug("data", `import_project backupCleanup: ${errorMessage(err)}`);
                 }
             }
             return mcpResponse({