@phren/cli 0.0.50 → 0.0.53

package/mcp/dist/tools/search.js

@@ -3,6 +3,7 @@ import { z } from "zod";
 import * as fs from "fs";
 import * as path from "path";
 import { createHash } from "crypto";
+import { execFileSync } from "child_process";
 import { isValidProjectName, errorMessage } from "../utils.js";
 import { resolveAllStores } from "../store-registry.js";
 import { readFindings } from "../data/access.js";
@@ -529,14 +530,13 @@ async function handleListProjects(ctx, { page, page_size }) {
         ? projectRows.map(row => decodeStringRow(row, 1, "list_projects.projects")[0])
         : [];
     // Gather projects from non-primary stores
-    const { getNonPrimaryStores } = await import("../store-registry.js");
-    const { getProjectDirs } = await import("../phren-paths.js");
+    const { getNonPrimaryStores, getStoreProjectDirs } = await import("../store-registry.js");
     const nonPrimaryStores = getNonPrimaryStores(phrenPath);
     const storeProjects = [];
     for (const store of nonPrimaryStores) {
         if (!fs.existsSync(store.path))
             continue;
-        const dirs = getProjectDirs(store.path);
+        const dirs = getStoreProjectDirs(store);
         for (const dir of dirs) {
             const projName = path.basename(dir);
             storeProjects.push({ name: projName, store: store.name });
@@ -691,12 +691,11 @@ async function handleStoreList(ctx) {
     const { phrenPath } = ctx;
     const stores = resolveAllStores(phrenPath);
     const storeData = stores.map((store) => {
-        let health = null;
+        // Get last sync time from git log
+        let lastSync = null;
         try {
-            const healthPath = path.join(store.path, ".runtime", "health.json");
-            if (fs.existsSync(healthPath)) {
-                health = JSON.parse(fs.readFileSync(healthPath, "utf8"))?.lastSync ?? null;
-            }
+            const result = execFileSync("git", ["log", "-1", "--format=%ci"], { cwd: store.path, encoding: "utf8", timeout: 3000 }).trim();
+            lastSync = result || null;
         }
         catch { /* non-critical */ }
         return {
@@ -708,7 +707,7 @@ async function handleStoreList(ctx) {
             remote: store.remote ?? null,
             exists: fs.existsSync(store.path),
             projects: store.projects ?? null,
-            lastSync: health,
+            lastSync,
         };
     });
     const lines = storeData.map((s) => {

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, getStoreProjectDirs } = await import("../store-registry.js");
+            for (const store of getNonPrimaryStores(phrenPath)) {
+                if (!fs.existsSync(store.path))
+                    continue;
+                const storeDirs = getStoreProjectDirs(store).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 } });
         });
     });