@phren/cli 0.0.49 → 0.0.52

package/mcp/dist/tools/session.js

@@ -1,4 +1,4 @@
-import { mcpResponse } from "./types.js";
+import { mcpResponse, resolveStoreForProject } from "./types.js";
 import { z } from "zod";
 import * as fs from "fs";
 import * as path from "path";
@@ -305,16 +305,21 @@ export function listAllSessions(phrenPath, limit = 50) {
     entries.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
     return entries;
 }
-export function getSessionArtifacts(phrenPath, sessionId, project) {
+export async function getSessionArtifacts(phrenPath, sessionId, project) {
     const findings = [];
     const tasks = [];
     const shortId = sessionId.slice(0, 8);
     try {
+        // Primary store projects
         const projectDirs = getProjectDirs(phrenPath);
         const targetProjects = project ? [project] : projectDirs.map((d) => path.basename(d));
-        for (const proj of targetProjects) {
+        const seen = new Set();
+        const readProjectArtifacts = (storePath, proj) => {
+            if (seen.has(proj))
+                return;
+            seen.add(proj);
             // Findings with matching sessionId
-            const findingsResult = readFindings(phrenPath, proj);
+            const findingsResult = readFindings(storePath, proj);
             if (findingsResult.ok) {
                 for (const f of findingsResult.data) {
                     if (f.sessionId && (f.sessionId === sessionId || f.sessionId.startsWith(shortId))) {
@@ -328,7 +333,7 @@ export function getSessionArtifacts(phrenPath, sessionId, project) {
                 }
             }
             // Tasks with matching sessionId
-            const tasksResult = readTasks(phrenPath, proj);
+            const tasksResult = readTasks(storePath, proj);
             if (tasksResult.ok) {
                 for (const section of ["Active", "Queue", "Done"]) {
                     for (const t of tasksResult.data.items[section]) {
@@ -344,15 +349,32 @@ export function getSessionArtifacts(phrenPath, sessionId, project) {
                     }
                 }
             }
+        };
+        for (const proj of targetProjects) {
+            readProjectArtifacts(phrenPath, proj);
+        }
+        // Team store projects
+        try {
+            const { getNonPrimaryStores } = await import("../store-registry.js");
+            for (const store of getNonPrimaryStores(phrenPath)) {
+                if (!fs.existsSync(store.path))
+                    continue;
+                const storeDirs = getProjectDirs(store.path).map(d => path.basename(d)).filter(p => p !== "global");
+                const storeTargetProjects = project ? (storeDirs.includes(project) ? [project] : []) : storeDirs;
+                for (const proj of storeTargetProjects) {
+                    readProjectArtifacts(store.path, proj);
+                }
+            }
         }
+        catch { /* store-registry not available */ }
     }
     catch (err) {
         debugLog(`getSessionArtifacts error: ${errorMessage(err)}`);
     }
     return { findings, tasks };
 }
-function hasCompletedTasksInSession(phrenPath, sessionId, project) {
-    const artifacts = getSessionArtifacts(phrenPath, sessionId, project);
+async function hasCompletedTasksInSession(phrenPath, sessionId, project) {
+    const artifacts = await getSessionArtifacts(phrenPath, sessionId, project);
     return artifacts.tasks.some((task) => task.section === "Done" && task.checked);
 }
 /** Compute what changed since the last session ended. */
@@ -448,8 +470,16 @@ export function register(server, ctx) {
         const activeProject = project ?? priorProject;
         const activeScope = normalizedAgentScope;
         if (activeProject && isValidProjectName(activeProject)) {
+            const projectStorePath = (() => {
+                try {
+                    return resolveStoreForProject(ctx, activeProject).phrenPath;
+                }
+                catch {
+                    return phrenPath;
+                }
+            })();
             try {
-                const findings = readFindings(phrenPath, activeProject);
+                const findings = readFindings(projectStorePath, activeProject);
                 if (findings.ok) {
                     const bullets = findings.data
                         .filter((entry) => isMemoryScopeVisible(normalizeMemoryScope(entry.scope), activeScope))
@@ -464,7 +494,7 @@ export function register(server, ctx) {
                 debugError("session_start findingsRead", err);
             }
             try {
-                const tasks = readTasks(phrenPath, activeProject);
+                const tasks = readTasks(projectStorePath, activeProject);
                 if (tasks.ok) {
                     const activeItems = tasks.data.items.Active
                         .filter((entry) => isMemoryScopeVisible(normalizeMemoryScope(entry.scope), activeScope))
@@ -480,7 +510,7 @@ export function register(server, ctx) {
             }
             // Surface extracted preferences/facts for this project
             try {
-                const facts = readExtractedFacts(phrenPath, activeProject).slice(-10);
+                const facts = readExtractedFacts(projectStorePath, activeProject).slice(-10);
                 if (facts.length > 0) {
                     parts.push(`## Preferences (${activeProject})\n${facts.map(f => `- ${f.fact}`).join("\n")}`);
                 }
@@ -489,7 +519,7 @@ export function register(server, ctx) {
                 debugError("session_start factsRead", err);
             }
             try {
-                const checkpoints = listTaskCheckpoints(phrenPath, activeProject).slice(0, 3);
+                const checkpoints = listTaskCheckpoints(projectStorePath, activeProject).slice(0, 3);
                 if (checkpoints.length > 0) {
                     const lines = [];
                     for (const checkpoint of checkpoints) {
@@ -600,19 +630,29 @@ export function register(server, ctx) {
             writeLastSummary(phrenPath, effectiveSummary, state.sessionId, endedState.project);
         }
         if (endedState.project && isValidProjectName(endedState.project)) {
+            const projectStorePath = (() => {
+                if (!endedState.project)
+                    return phrenPath;
+                try {
+                    return resolveStoreForProject(ctx, endedState.project).phrenPath;
+                }
+                catch {
+                    return phrenPath;
+                }
+            })();
             try {
-                const trackedActiveTask = getActiveTaskForSession(phrenPath, state.sessionId, endedState.project);
+                const trackedActiveTask = getActiveTaskForSession(projectStorePath, state.sessionId, endedState.project);
                 const activeTask = trackedActiveTask ?? (() => {
-                    const tasks = readTasks(phrenPath, endedState.project);
+                    const tasks = readTasks(projectStorePath, endedState.project);
                     if (!tasks.ok)
                         return null;
                     return tasks.data.items.Active[0] ?? null;
                 })();
                 if (activeTask) {
                     const taskId = activeTask.stableId || activeTask.id;
-                    const projectConfig = readProjectConfig(phrenPath, endedState.project);
-                    const snapshotRoot = getProjectSourcePath(phrenPath, endedState.project, projectConfig) ||
-                        path.join(phrenPath, endedState.project);
+                    const projectConfig = readProjectConfig(projectStorePath, endedState.project);
+                    const snapshotRoot = getProjectSourcePath(projectStorePath, endedState.project, projectConfig) ||
+                        path.join(projectStorePath, endedState.project);
                     const { gitStatus, editedFiles } = collectGitStatusSnapshot(snapshotRoot);
                     const resumptionHint = extractResumptionHint(effectiveSummary, activeTask.line, activeTask.context || "No prior attempt captured");
                     writeTaskCheckpoint(phrenPath, {
@@ -635,7 +675,7 @@ export function register(server, ctx) {
         }
         try {
             const tasksCompleted = Number.isFinite(endedState.tasksCompleted) ? endedState.tasksCompleted : 0;
-            if (tasksCompleted > 0 || hasCompletedTasksInSession(phrenPath, state.sessionId, endedState.project)) {
+            if (tasksCompleted > 0 || await hasCompletedTasksInSession(phrenPath, state.sessionId, endedState.project)) {
                 markImpactEntriesCompletedForSession(phrenPath, state.sessionId, endedState.project);
             }
         }
@@ -707,7 +747,7 @@ export function register(server, ctx) {
             const session = sessions.find(s => s.sessionId === targetSessionId || s.sessionId.startsWith(targetSessionId));
             if (!session)
                 return mcpResponse({ ok: false, error: `Session ${targetSessionId} not found.` });
-            const artifacts = getSessionArtifacts(phrenPath, session.sessionId, project);
+            const artifacts = await getSessionArtifacts(phrenPath, session.sessionId, project);
             const parts = [
                 `Session: ${session.sessionId.slice(0, 8)}`,
                 `Project: ${session.project ?? "none"}`,

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.49",
+  "version": "0.0.52",
   "description": "Knowledge layer for AI agents. Phren learns and recalls.",
   "type": "module",
   "bin": {