@phren/cli 0.0.50 → 0.0.52

package/mcp/dist/tools/tasks.js

@@ -109,7 +109,8 @@ export function register(server, ctx) {
                 return mcpResponse({ ok: false, error: "Provide `project` when looking up a single item." });
             if (!isValidProjectName(project))
                 return mcpResponse({ ok: false, error: `Invalid project name: "${project}"` });
-            const result = readTasks(phrenPath, project);
+            const resolvedPath = resolveStoreForProject(ctx, project).phrenPath;
+            const result = readTasks(resolvedPath, project);
             if (!result.ok)
                 return mcpResponse({ ok: false, error: result.error });
             const doc = result.data;
@@ -141,7 +142,8 @@ export function register(server, ctx) {
         if (project) {
             if (!isValidProjectName(project))
                 return mcpResponse({ ok: false, error: `Invalid project name: "${project}"` });
-            const result = readTasks(phrenPath, project);
+            const resolvedPath = resolveStoreForProject(ctx, project).phrenPath;
+            const result = readTasks(resolvedPath, project);
             if (!result.ok)
                 return mcpResponse({ ok: false, error: result.error });
             const doc = result.data;
@@ -257,21 +259,24 @@ export function register(server, ctx) {
             ]).describe("The task(s) to complete. Pass a string for one, or an array for bulk."),
             sessionId: z.string().optional().describe("Optional session ID from session_start. Pass this to track per-session task completion metrics."),
         }),
-    }, async ({ project, item, sessionId }) => {
+    }, async ({ project: projectInput, item, sessionId }) => {
+        const resolved = resolveStoreForProject(ctx, projectInput);
+        const project = resolved.project;
+        const targetPath = resolved.phrenPath;
         if (!isValidProjectName(project))
             return mcpResponse({ ok: false, error: `Invalid project name: "${project}"` });
-        const completeTaskDenied = permissionDeniedError(phrenPath, "complete_task", project);
+        const completeTaskDenied = permissionDeniedError(targetPath, "complete_task", project);
         if (completeTaskDenied)
             return mcpResponse({ ok: false, error: completeTaskDenied });
         if (Array.isArray(item)) {
             return withWriteQueue(async () => {
                 const resolvedItems = item
                     .map((match) => {
-                    const resolved = resolveTaskItem(phrenPath, project, match);
-                    return resolved.ok ? resolved.data : null;
+                    const resolvedItem = resolveTaskItem(targetPath, project, match);
+                    return resolvedItem.ok ? resolvedItem.data : null;
                 })
                     .filter((task) => task !== null);
-                const result = completeTasksBatch(phrenPath, project, item);
+                const result = completeTasksBatch(targetPath, project, item);
                 if (!result.ok)
                     return mcpResponse({ ok: false, error: result.error });
                 const { completed, errors } = result.data;
@@ -280,7 +285,7 @@ export function register(server, ctx) {
                     for (const task of resolvedItems) {
                         if (!completedSet.has(task.line))
                             continue;
-                        clearTaskCheckpoint(phrenPath, {
+                        clearTaskCheckpoint(targetPath, {
                             project,
                             taskId: task.stableId ?? task.id,
                             stableId: task.stableId,
@@ -288,20 +293,20 @@ export function register(server, ctx) {
                             taskLine: task.line,
                         });
                     }
-                    incrementSessionTasksCompleted(phrenPath, completed.length, sessionId, project);
+                    incrementSessionTasksCompleted(targetPath, completed.length, sessionId, project);
                 }
                 if (completed.length > 0)
-                    refreshTaskIndex(updateFileInIndex, phrenPath, project);
+                    refreshTaskIndex(updateFileInIndex, targetPath, project);
                 return mcpResponse({ ok: completed.length > 0, ...(completed.length === 0 ? { error: `No tasks completed: ${errors.join("; ")}` } : {}), message: `Completed ${completed.length}/${item.length} items`, data: { project, completed, errors } });
             });
         }
         return withWriteQueue(async () => {
-            const before = resolveTaskItem(phrenPath, project, item);
-            const result = completeTaskStore(phrenPath, project, item);
+            const before = resolveTaskItem(targetPath, project, item);
+            const result = completeTaskStore(targetPath, project, item);
             if (!result.ok)
                 return mcpResponse({ ok: false, error: result.error });
             if (before.ok) {
-                clearTaskCheckpoint(phrenPath, {
+                clearTaskCheckpoint(targetPath, {
                     project,
                     taskId: before.data.stableId ?? before.data.id,
                     stableId: before.data.stableId,
@@ -309,8 +314,8 @@ export function register(server, ctx) {
                     taskLine: before.data.line,
                 });
             }
-            incrementSessionTasksCompleted(phrenPath, 1, sessionId, project);
-            refreshTaskIndex(updateFileInIndex, phrenPath, project);
+            incrementSessionTasksCompleted(targetPath, 1, sessionId, project);
+            refreshTaskIndex(updateFileInIndex, targetPath, project);
             return mcpResponse({ ok: true, message: result.data, data: { project, item } });
         });
     });
@@ -324,28 +329,31 @@ export function register(server, ctx) {
                 z.array(z.string()).describe("List of partial item texts or IDs to remove."),
             ]).describe("The task(s) to remove. Pass a string for one, or an array for bulk."),
         }),
-    }, async ({ project, item }) => {
+    }, async ({ project: projectInput, item }) => {
+        const resolved = resolveStoreForProject(ctx, projectInput);
+        const project = resolved.project;
+        const targetPath = resolved.phrenPath;
         if (!isValidProjectName(project))
             return mcpResponse({ ok: false, error: `Invalid project name: "${project}"` });
-        const removeTaskDenied = permissionDeniedError(phrenPath, "remove_task", project);
+        const removeTaskDenied = permissionDeniedError(targetPath, "remove_task", project);
         if (removeTaskDenied)
             return mcpResponse({ ok: false, error: removeTaskDenied });
         if (Array.isArray(item)) {
             return withWriteQueue(async () => {
-                const result = removeTasksBatch(phrenPath, project, item);
+                const result = removeTasksBatch(targetPath, project, item);
                 if (!result.ok)
                     return mcpResponse({ ok: false, error: result.error });
                 const { removed, errors } = result.data;
                 if (removed.length > 0)
-                    refreshTaskIndex(updateFileInIndex, phrenPath, project);
+                    refreshTaskIndex(updateFileInIndex, targetPath, project);
                 return mcpResponse({ ok: removed.length > 0, ...(removed.length === 0 ? { error: `No tasks removed: ${errors.join("; ")}` } : {}), message: `Removed ${removed.length}/${item.length} items`, data: { project, removed, errors } });
             });
         }
         return withWriteQueue(async () => {
-            const result = removeTaskStore(phrenPath, project, item);
+            const result = removeTaskStore(targetPath, project, item);
             if (!result.ok)
                 return mcpResponse({ ok: false, error: result.error });
-            refreshTaskIndex(updateFileInIndex, phrenPath, project);
+            refreshTaskIndex(updateFileInIndex, targetPath, project);
             return mcpResponse({ ok: true, message: result.data, data: { project, item } });
         });
     });
@@ -373,10 +381,13 @@ export function register(server, ctx) {
                 work_next: z.boolean().optional().describe("If true, pick the highest-priority Queue item and move it to Active. Ignores item param."),
             }).describe("Fields to update. All are optional."),
         }),
-    }, async ({ project, item, updates }) => {
+    }, async ({ project: projectInput, item, updates }) => {
+        const resolved = resolveStoreForProject(ctx, projectInput);
+        const project = resolved.project;
+        const targetPath = resolved.phrenPath;
         if (!isValidProjectName(project))
             return mcpResponse({ ok: false, error: `Invalid project name: "${project}"` });
-        const updateTaskDenied = permissionDeniedError(phrenPath, "update_task", project);
+        const updateTaskDenied = permissionDeniedError(targetPath, "update_task", project);
         if (updateTaskDenied)
             return mcpResponse({ ok: false, error: updateTaskDenied });
         // Runtime validation: item is required unless work_next is true
@@ -417,26 +428,26 @@ export function register(server, ctx) {
         return withWriteQueue(async () => {
             // Handle work_next: pick highest-priority Queue item, move to Active
             if (updates.work_next) {
-                const result = workNextTask(phrenPath, project);
+                const result = workNextTask(targetPath, project);
                 if (!result.ok)
                     return mcpResponse({ ok: false, error: result.error });
-                refreshTaskIndex(updateFileInIndex, phrenPath, project);
+                refreshTaskIndex(updateFileInIndex, targetPath, project);
                 return mcpResponse({ ok: true, message: result.data, data: { project } });
             }
             // Handle pin
             if (updates.pin) {
-                const result = pinTask(phrenPath, project, item);
+                const result = pinTask(targetPath, project, item);
                 if (!result.ok)
                     return mcpResponse({ ok: false, error: result.error });
-                refreshTaskIndex(updateFileInIndex, phrenPath, project);
+                refreshTaskIndex(updateFileInIndex, targetPath, project);
                 return mcpResponse({ ok: true, message: result.data, data: { project, item } });
             }
             // Handle promote (clear speculative flag)
             if (updates.promote) {
-                const result = promoteTask(phrenPath, project, item, updates.move_to_active ?? false);
+                const result = promoteTask(targetPath, project, item, updates.move_to_active ?? false);
                 if (!result.ok)
                     return mcpResponse({ ok: false, error: result.error });
-                refreshTaskIndex(updateFileInIndex, phrenPath, project);
+                refreshTaskIndex(updateFileInIndex, targetPath, project);
                 return mcpResponse({
                     ok: true,
                     message: `Promoted task "${result.data.line}" in ${project}${updates.move_to_active ? " (moved to Active)" : ""}.`,
@@ -444,10 +455,10 @@ export function register(server, ctx) {
                 });
             }
             if (updates.create_issue) {
-                const resolved = resolveTaskItem(phrenPath, project, item);
-                if (!resolved.ok)
-                    return mcpResponse({ ok: false, error: resolved.error });
-                const repo = resolveProjectGithubRepo(phrenPath, project);
+                const resolvedItem = resolveTaskItem(targetPath, project, item);
+                if (!resolvedItem.ok)
+                    return mcpResponse({ ok: false, error: resolvedItem.error });
+                const repo = resolveProjectGithubRepo(targetPath, project);
                 if (!repo) {
                     return mcpResponse({
                         ok: false,
@@ -456,18 +467,18 @@ export function register(server, ctx) {
                 }
                 const created = createGithubIssueForTask({
                     repo,
-                    title: resolved.data.line.replace(/\s*\[(high|medium|low)\]\s*$/i, "").trim(),
-                    body: buildTaskIssueBody(project, resolved.data),
+                    title: resolvedItem.data.line.replace(/\s*\[(high|medium|low)\]\s*$/i, "").trim(),
+                    body: buildTaskIssueBody(project, resolvedItem.data),
                 });
                 if (!created.ok)
                     return mcpResponse({ ok: false, error: created.error, errorCode: created.code });
-                const linked = linkTaskIssue(phrenPath, project, item, {
+                const linked = linkTaskIssue(targetPath, project, item, {
                     github_issue: created.data.issueNumber,
                     github_url: created.data.url,
                 });
                 if (!linked.ok)
                     return mcpResponse({ ok: false, error: linked.error, errorCode: linked.code });
-                refreshTaskIndex(updateFileInIndex, phrenPath, project);
+                refreshTaskIndex(updateFileInIndex, targetPath, project);
                 return mcpResponse({
                     ok: true,
                     message: `Created GitHub issue ${created.data.issueNumber ? `#${created.data.issueNumber}` : created.data.url} for ${project} task.`,
@@ -487,14 +498,14 @@ export function register(server, ctx) {
                 if (updates.unlink_github && (updates.github_issue !== undefined || updates.github_url)) {
                     return mcpResponse({ ok: false, error: "Use either unlink_github=true or github_issue/github_url, not both." });
                 }
-                const result = linkTaskIssue(phrenPath, project, item, {
+                const result = linkTaskIssue(targetPath, project, item, {
                     github_issue: updates.github_issue,
                     github_url: updates.github_url,
                     unlink: updates.unlink_github ?? false,
                 });
                 if (!result.ok)
                     return mcpResponse({ ok: false, error: result.error, errorCode: result.code });
-                refreshTaskIndex(updateFileInIndex, phrenPath, project);
+                refreshTaskIndex(updateFileInIndex, targetPath, project);
                 return mcpResponse({
                     ok: true,
                     message: updates.unlink_github
@@ -510,10 +521,10 @@ export function register(server, ctx) {
                 });
             }
             // Standard update path
-            const result = updateTaskStore(phrenPath, project, item, updates);
+            const result = updateTaskStore(targetPath, project, item, updates);
             if (!result.ok)
                 return mcpResponse({ ok: false, error: result.error });
-            refreshTaskIndex(updateFileInIndex, phrenPath, project);
+            refreshTaskIndex(updateFileInIndex, targetPath, project);
             return mcpResponse({ ok: true, message: result.data, data: { project, item, updates } });
         });
     });
@@ -525,15 +536,18 @@ export function register(server, ctx) {
             keep: z.number().optional().describe("Number of recent Done items to keep. Default 30."),
             dry_run: z.boolean().optional().describe("If true, preview changes without writing."),
         }),
-    }, async ({ project, keep, dry_run }) => {
+    }, async ({ project: projectInput, keep, dry_run }) => {
+        const resolved = resolveStoreForProject(ctx, projectInput);
+        const project = resolved.project;
+        const targetPath = resolved.phrenPath;
         if (!isValidProjectName(project))
             return mcpResponse({ ok: false, error: `Invalid project name: "${project}"` });
         return withWriteQueue(async () => {
-            const result = tidyDoneTasks(phrenPath, project, keep ?? 30, dry_run ?? false);
+            const result = tidyDoneTasks(targetPath, project, keep ?? 30, dry_run ?? false);
             if (!result.ok)
                 return mcpResponse({ ok: false, error: result.error });
             if (!dry_run)
-                refreshTaskIndex(updateFileInIndex, phrenPath, project);
+                refreshTaskIndex(updateFileInIndex, targetPath, project);
             return mcpResponse({ ok: true, message: result.data, data: { project, keep: keep ?? 30, dryRun: dry_run ?? false } });
         });
     });

package/mcp/dist/ui/data.js

@@ -151,42 +151,69 @@ export function getHooksData(phrenPath, profile) {
     return { globalEnabled, tools, customHooks: readCustomHooks(phrenPath), projectOverrides };
 }
 export async function buildGraph(phrenPath, profile, focusProject, existingDb) {
-    const projects = getProjectDirs(phrenPath, profile).map((projectDir) => path.basename(projectDir)).filter((project) => project !== "global");
+    // Collect projects from primary store and all readable non-primary stores
+    const storeProjects = [];
+    const primaryProjects = getProjectDirs(phrenPath, profile)
+        .map((projectDir) => path.basename(projectDir))
+        .filter((project) => project !== "global");
+    for (const project of primaryProjects)
+        storeProjects.push({ storePath: phrenPath, project });
+    for (const store of getNonPrimaryStores(phrenPath)) {
+        if (!fs.existsSync(store.path))
+            continue;
+        try {
+            const storeProjectDirs = getProjectDirs(store.path)
+                .map((projectDir) => path.basename(projectDir))
+                .filter((project) => project !== "global");
+            for (const project of storeProjectDirs)
+                storeProjects.push({ storePath: store.path, project });
+        }
+        catch { /* store not accessible — skip */ }
+    }
+    const projects = storeProjects.map((sp) => sp.project);
     const nodes = [];
     const links = [];
     const projectSet = new Set(projects);
     // Collect all unique topics across projects for the UI
     const topicMetaMap = new Map();
-    for (const project of projects) {
+    // Track which project nodes have already been pushed (same name may appear in multiple stores)
+    const addedProjectNodeIds = new Set();
+    for (const { storePath, project } of storeProjects) {
         // Load dynamic topics for this project
-        const { topics: projectTopics } = readProjectTopics(phrenPath, project);
+        const { topics: projectTopics } = readProjectTopics(storePath, project);
         for (const topic of projectTopics) {
             if (!topicMetaMap.has(topic.slug)) {
                 topicMetaMap.set(topic.slug, { slug: topic.slug, label: topic.label });
             }
         }
-        const findingsPath = path.join(phrenPath, project, "FINDINGS.md");
+        const findingsPath = path.join(storePath, project, "FINDINGS.md");
         if (!fs.existsSync(findingsPath)) {
+            if (!addedProjectNodeIds.has(project)) {
+                addedProjectNodeIds.add(project);
+                nodes.push({
+                    id: project,
+                    label: project,
+                    fullLabel: project,
+                    group: "project",
+                    refCount: 0,
+                    project,
+                    tagged: false,
+                });
+            }
+            continue;
+        }
+        if (!addedProjectNodeIds.has(project)) {
+            addedProjectNodeIds.add(project);
             nodes.push({
                 id: project,
                 label: project,
                 fullLabel: project,
                 group: "project",
-                refCount: 0,
+                refCount: 1,
                 project,
                 tagged: false,
             });
-            continue;
         }
-        nodes.push({
-            id: project,
-            label: project,
-            fullLabel: project,
-            group: "project",
-            refCount: 1,
-            project,
-            tagged: false,
-        });
         const content = fs.readFileSync(findingsPath, "utf8");
         const lines = content.split("\n");
         // No cap for focused project; high caps otherwise
@@ -316,8 +343,8 @@ export async function buildGraph(phrenPath, profile, focusProject, existingDb) {
     }
     // ── Tasks ──────────────────────────────────────────────────────────
     try {
-        for (const project of projects) {
-            const taskResult = readTasks(phrenPath, project);
+        for (const { storePath, project } of storeProjects) {
+            const taskResult = readTasks(storePath, project);
             if (!taskResult.ok)
                 continue;
             const doc = taskResult.data;
@@ -443,8 +470,8 @@ export async function buildGraph(phrenPath, profile, focusProject, existingDb) {
     }
     // ── Reference docs ────────────────────────────────────────────────
     try {
-        for (const project of projects) {
-            const refDir = path.join(phrenPath, project, "reference");
+        for (const { storePath, project } of storeProjects) {
+            const refDir = path.join(storePath, project, "reference");
             if (!fs.existsSync(refDir) || !fs.statSync(refDir).isDirectory())
                 continue;
             const files = fs.readdirSync(refDir);

package/mcp/dist/ui/server.js

@@ -543,7 +543,8 @@ function handleGetFindings(res, pathname, ctx) {
     const project = decodeURIComponent(pathname.slice("/api/findings/".length));
     if (!project || !isValidProjectName(project))
         return jsonErr(res, "Invalid project name", 400);
-    const result = readFindings(ctx.phrenPath, project);
+    const basePath = resolveProjectBasePath(ctx.phrenPath, project);
+    const result = readFindings(basePath, project);
     jsonOk(res, result.ok ? { ok: true, data: { project, findings: result.data } } : { ok: false, error: result.error });
 }
 // ── POST handlers ─────────────────────────────────────────────────────────────

package/package.json

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