@phren/cli 0.0.41 → 0.0.42

package/mcp/dist/cli/cli.js

@@ -7,7 +7,7 @@ import { handleExtractMemories } from "./extract.js";
 import { handleGovernMemories, handlePruneMemories, handleConsolidateMemories, handleMaintain, handleBackgroundMaintenance, } from "./govern.js";
 import { handleConfig, handleIndexPolicy, handleRetentionPolicy, handleWorkflowPolicy, } from "./config.js";
 import { parseSearchArgs } from "./search.js";
-import { handleDetectSkills, handleFindingNamespace, handleHooksNamespace, handleProjectsNamespace, handleSkillsNamespace, handleSkillList, handleStoreNamespace, handleTaskNamespace, } from "./namespaces.js";
+import { handleDetectSkills, handleFindingNamespace, handleHooksNamespace, handleProjectsNamespace, handleSkillsNamespace, handleSkillList, handlePromoteNamespace, handleStoreNamespace, handleTaskNamespace, } from "./namespaces.js";
 import { handleTaskView, handleSessionsView, handleQuickstart, handleDebugInjection, handleInspectIndex, } from "./ops.js";
 import { handleAddFinding, handleDoctor, handleFragmentSearch, handleMemoryUi, handlePinCanonical, handleQualityFeedback, handleRelatedDocs, handleReview, handleConsolidationStatus, handleSessionContext, handleSearch, handleShell, handleStatus, handleUpdate, } from "./actions.js";
 import { handleGraphNamespace } from "./graph.js";
@@ -109,6 +109,8 @@ export async function runCliCommand(command, args) {
             return handleSessionContext();
         case "store":
             return handleStoreNamespace(args);
+        case "promote":
+            return handlePromoteNamespace(args);
         default:
             console.error(`Unknown command: ${command}\nRun 'phren --help' for available commands.`);
             process.exit(1);

package/mcp/dist/cli/namespaces.js

@@ -1509,6 +1509,7 @@ function printStoreUsage() {
     console.log("  phren store add <name> --remote <url>   Add a team store");
     console.log("  phren store remove <name>               Remove a store (local only)");
     console.log("  phren store sync                        Pull all stores");
+    console.log("  phren store activity [--limit N]         Recent team findings");
 }
 export async function handleStoreNamespace(args) {
     const subcommand = args[0];
@@ -1630,6 +1631,47 @@ export async function handleStoreNamespace(args) {
         }
         return;
     }
+    if (subcommand === "activity") {
+        const stores = resolveAllStores(phrenPath);
+        const teamStores = stores.filter((s) => s.role === "team");
+        if (teamStores.length === 0) {
+            console.log("No team stores registered. Add one with: phren store add <name> --remote <url>");
+            return;
+        }
+        const { readTeamJournalEntries } = await import("../finding/journal.js");
+        const limit = Number(getOptionValue(args.slice(1), "--limit") ?? "20");
+        const allEntries = [];
+        for (const store of teamStores) {
+            if (!fs.existsSync(store.path))
+                continue;
+            const projectDirs = getProjectDirs(store.path);
+            for (const dir of projectDirs) {
+                const projectName = path.basename(dir);
+                const journalEntries = readTeamJournalEntries(store.path, projectName);
+                for (const je of journalEntries) {
+                    for (const entry of je.entries) {
+                        allEntries.push({ store: store.name, project: projectName, date: je.date, actor: je.actor, entry });
+                    }
+                }
+            }
+        }
+        allEntries.sort((a, b) => b.date.localeCompare(a.date));
+        const capped = allEntries.slice(0, limit);
+        if (capped.length === 0) {
+            console.log("No team activity yet.");
+            return;
+        }
+        console.log(`Team activity (${capped.length}/${allEntries.length}):\n`);
+        let lastDate = "";
+        for (const e of capped) {
+            if (e.date !== lastDate) {
+                console.log(`## ${e.date}`);
+                lastDate = e.date;
+            }
+            console.log(`  [${e.store}/${e.project}] ${e.actor}: ${e.entry}`);
+        }
+        return;
+    }
     if (subcommand === "sync") {
         const stores = resolveAllStores(phrenPath);
         let hasErrors = false;
@@ -1665,6 +1707,72 @@ export async function handleStoreNamespace(args) {
     printStoreUsage();
     process.exit(1);
 }
+// ── Promote namespace ────────────────────────────────────────────────────────
+export async function handlePromoteNamespace(args) {
+    if (!args[0] || args[0] === "--help" || args[0] === "-h") {
+        console.log("Usage:");
+        console.log('  phren promote <project> "finding text..." --to <store>');
+        console.log("  Copies a finding from the primary store to a team store.");
+        return;
+    }
+    const phrenPath = getPhrenPath();
+    const project = args[0];
+    if (!isValidProjectName(project)) {
+        console.error(`Invalid project name: "${project}"`);
+        process.exit(1);
+    }
+    const toStore = getOptionValue(args.slice(1), "--to");
+    if (!toStore) {
+        console.error("--to <store> is required. Specify the target team store.");
+        process.exit(1);
+    }
+    // Everything between project and --to is the finding text
+    const toIdx = args.indexOf("--to");
+    const findingText = args.slice(1, toIdx !== -1 ? toIdx : undefined).join(" ").trim();
+    if (!findingText) {
+        console.error("Finding text is required.");
+        process.exit(1);
+    }
+    const stores = resolveAllStores(phrenPath);
+    const targetStore = stores.find((s) => s.name === toStore);
+    if (!targetStore) {
+        const available = stores.map((s) => s.name).join(", ");
+        console.error(`Store "${toStore}" not found. Available: ${available}`);
+        process.exit(1);
+    }
+    if (targetStore.role === "readonly") {
+        console.error(`Store "${toStore}" is read-only.`);
+        process.exit(1);
+    }
+    if (targetStore.role === "primary") {
+        console.error(`Cannot promote to primary store — finding is already there.`);
+        process.exit(1);
+    }
+    // Find the matching finding in the primary store
+    const { readFindings } = await import("../data/access.js");
+    const findingsResult = readFindings(phrenPath, project);
+    if (!findingsResult.ok) {
+        console.error(`Could not read findings for project "${project}".`);
+        process.exit(1);
+    }
+    const match = findingsResult.data.find((item) => item.text.includes(findingText) || findingText.includes(item.text));
+    if (!match) {
+        console.error(`No finding matching "${findingText.slice(0, 80)}..." found in ${project}.`);
+        process.exit(1);
+    }
+    // Write to target store
+    const targetProjectDir = path.join(targetStore.path, project);
+    fs.mkdirSync(targetProjectDir, { recursive: true });
+    const targetFindingsPath = path.join(targetProjectDir, "FINDINGS.md");
+    const { addFindingToFile } = await import("../shared/content.js");
+    const result = addFindingToFile(targetStore.path, project, match.text);
+    if (!result.ok) {
+        console.error(`Failed to add finding to ${toStore}: ${result.error}`);
+        process.exit(1);
+    }
+    console.log(`Promoted to ${toStore}/${project}:`);
+    console.log(`  "${match.text.slice(0, 120)}${match.text.length > 120 ? "..." : ""}"`);
+}
 function countStoreProjects(store) {
     if (!fs.existsSync(store.path))
         return 0;

package/mcp/dist/entrypoint.js

@@ -175,6 +175,7 @@ const CLI_COMMANDS = [
     "consolidation-status",
     "session-context",
     "store",
+    "promote",
 ];
 async function flushTopLevelOutput() {
     await Promise.all([

package/mcp/dist/finding/journal.js

@@ -1,7 +1,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import * as crypto from "crypto";
-import { runtimeDir, phrenOk, phrenErr, PhrenError } from "../shared.js";
+import { runtimeDir, phrenOk, phrenErr, PhrenError, atomicWriteText } from "../shared.js";
 import { withFileLock } from "../shared/governance.js";
 import { addFindingToFile } from "../shared/content.js";
 import { isValidProjectName, errorMessage } from "../utils.js";
@@ -120,3 +120,90 @@ export function compactFindingJournals(phrenPath, project) {
     }
     return result;
 }
+// ── Team store journal (append-only markdown, committed to git) ──────────────
+const TEAM_JOURNAL_DIR = "journal";
+/**
+ * Append a finding to a team store's journal.
+ * Each actor gets one file per day — no merge conflicts possible.
+ * These are markdown files committed to git (not runtime JSONL).
+ */
+export function appendTeamJournal(storePath, project, finding, actor) {
+    const resolvedActor = actor || process.env.PHREN_ACTOR || process.env.USER || "unknown";
+    const date = new Date().toISOString().slice(0, 10);
+    const journalDir = path.join(storePath, project, TEAM_JOURNAL_DIR);
+    const journalFile = `${date}-${resolvedActor}.md`;
+    const journalPath = path.join(journalDir, journalFile);
+    try {
+        fs.mkdirSync(journalDir, { recursive: true });
+        const entry = `- ${finding}\n`;
+        if (fs.existsSync(journalPath)) {
+            fs.appendFileSync(journalPath, entry);
+        }
+        else {
+            fs.writeFileSync(journalPath, `## ${date} (${resolvedActor})\n\n${entry}`);
+        }
+        return phrenOk(journalFile);
+    }
+    catch (err) {
+        return phrenErr(`Team journal append failed: ${errorMessage(err)}`, PhrenError.PERMISSION_DENIED);
+    }
+}
+/**
+ * Read all team journal entries for a project, newest first.
+ */
+export function readTeamJournalEntries(storePath, project) {
+    const journalDir = path.join(storePath, project, TEAM_JOURNAL_DIR);
+    if (!fs.existsSync(journalDir))
+        return [];
+    return fs.readdirSync(journalDir)
+        .filter((f) => f.endsWith(".md"))
+        .sort()
+        .reverse()
+        .map((file) => {
+        const match = file.match(/^(\d{4}-\d{2}-\d{2})-(.+)\.md$/);
+        const date = match?.[1] ?? "unknown";
+        const actor = match?.[2] ?? "unknown";
+        const content = fs.readFileSync(path.join(journalDir, file), "utf8");
+        const entries = content.split("\n")
+            .filter((line) => line.startsWith("- "))
+            .map((line) => line.slice(2).trim());
+        return { file, date, actor, entries };
+    });
+}
+/**
+ * Materialize FINDINGS.md from team journal entries.
+ * Groups by date, includes actor attribution.
+ */
+export function materializeTeamFindings(storePath, project) {
+    const journalEntries = readTeamJournalEntries(storePath, project);
+    if (journalEntries.length === 0) {
+        return phrenErr("No journal entries found", PhrenError.FILE_NOT_FOUND);
+    }
+    // Group by date, chronological order
+    const byDate = new Map();
+    for (const entry of [...journalEntries].reverse()) {
+        if (!byDate.has(entry.date))
+            byDate.set(entry.date, []);
+        byDate.get(entry.date).push({ actor: entry.actor, entries: entry.entries });
+    }
+    const lines = [`# ${project} findings\n`];
+    let count = 0;
+    for (const [date, actors] of byDate) {
+        lines.push(`## ${date}`);
+        for (const { actor, entries } of actors) {
+            for (const entry of entries) {
+                lines.push(`- ${entry} <!-- author:${actor} -->`);
+                count++;
+            }
+        }
+        lines.push("");
+    }
+    const findingsPath = path.join(storePath, project, "FINDINGS.md");
+    try {
+        atomicWriteText(findingsPath, lines.join("\n"));
+        return phrenOk({ entryCount: count });
+    }
+    catch (err) {
+        return phrenErr(`Materialize failed: ${errorMessage(err)}`, PhrenError.PERMISSION_DENIED);
+    }
+}

package/mcp/dist/tools/finding.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";
@@ -84,13 +84,45 @@ function withLifecycleMutation(phrenPath, project, writeQueue, updateIndex, hand
     });
 }
 // ── Handlers ─────────────────────────────────────────────────────────────────
-async function handleAddFinding(ctx, { project, finding, citation, sessionId, source, findingType, scope }) {
-    const { phrenPath, withWriteQueue, updateFileInIndex } = ctx;
+async function handleAddFinding(ctx, params) {
+    const { finding, citation, sessionId, source, findingType, scope } = params;
+    // Resolve store-qualified project names (e.g., "team/arc" → store path + "arc")
+    let phrenPath;
+    let project;
+    try {
+        const resolved = resolveStoreForProject(ctx, params.project);
+        phrenPath = resolved.phrenPath;
+        project = resolved.project;
+    }
+    catch (err) {
+        return mcpResponse({ ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+    const { withWriteQueue, updateFileInIndex } = ctx;
     if (!isValidProjectName(project))
         return mcpResponse({ ok: false, error: `Invalid project name: "${project}"` });
     const addFindingDenied = permissionDeniedError(phrenPath, "add_finding", project);
     if (addFindingDenied)
         return mcpResponse({ ok: false, error: addFindingDenied });
+    // Team stores: use append-only journal (no FINDINGS.md mutation, no merge conflicts)
+    {
+        const storeResolved = resolveStoreForProject(ctx, params.project);
+        if (storeResolved.storeRole === "team") {
+            const { appendTeamJournal } = await import("../finding/journal.js");
+            const findings = Array.isArray(finding) ? finding : [finding];
+            const added = [];
+            for (const f of findings) {
+                const taggedFinding = findingType ? `[${findingType}] ${f}` : f;
+                const result = appendTeamJournal(phrenPath, project, taggedFinding);
+                if (result.ok)
+                    added.push(taggedFinding);
+            }
+            return mcpResponse({
+                ok: added.length > 0,
+                message: `Added ${added.length} finding(s) to ${params.project} journal`,
+                data: { project: params.project, added, journalMode: true },
+            });
+        }
+    }
     if (Array.isArray(finding)) {
         const findings = finding;
         if (findings.length > 100)

package/mcp/dist/tools/search.js

@@ -458,8 +458,28 @@ async function handleSearchKnowledge(ctx, { query, limit, project, type, tag, si
     }
 }
 async function handleGetProjectSummary(ctx, { name }) {
+    // Support store-qualified names (e.g., "team/arc")
+    const { parseStoreQualified } = await import("../store-routing.js");
+    const { storeName, projectName } = parseStoreQualified(name);
+    const lookupName = projectName;
     const db = ctx.db();
-    const docs = queryDocRows(db, "SELECT project, filename, type, content, path FROM docs WHERE project = ?", [name]);
+    let docs = queryDocRows(db, "SELECT project, filename, type, content, path FROM docs WHERE project = ?", [lookupName]);
+    // If not in primary index and store-qualified, try reading from the store's filesystem
+    if (!docs && storeName) {
+        const store = resolveAllStores(ctx.phrenPath).find((s) => s.name === storeName);
+        if (store && fs.existsSync(path.join(store.path, lookupName))) {
+            const projDir = path.join(store.path, lookupName);
+            const fsDocs = [];
+            for (const [file, type] of [["summary.md", "summary"], ["CLAUDE.md", "claude"], ["FINDINGS.md", "findings"], ["tasks.md", "task"]]) {
+                const filePath = path.join(projDir, file);
+                if (fs.existsSync(filePath)) {
+                    fsDocs.push({ filename: file, type, content: fs.readFileSync(filePath, "utf8").slice(0, 8000), path: filePath });
+                }
+            }
+            if (fsDocs.length > 0)
+                docs = fsDocs;
+        }
+    }
     if (!docs) {
         const projectRows = queryRows(db, "SELECT DISTINCT project FROM docs ORDER BY project", []);
         const names = projectRows ? projectRows.map(row => decodeStringRow(row, 1, "get_project_summary.projects")[0]) : [];
@@ -494,42 +514,83 @@ async function handleGetProjectSummary(ctx, { name }) {
 async function handleListProjects(ctx, { page, page_size }) {
     const { phrenPath, profile } = ctx;
     const db = ctx.db();
+    // Gather projects from primary store index
     const projectRows = queryRows(db, "SELECT DISTINCT project FROM docs ORDER BY project", []);
-    if (!projectRows)
+    const primaryProjects = projectRows
+        ? 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 nonPrimaryStores = getNonPrimaryStores(phrenPath);
+    const storeProjects = [];
+    for (const store of nonPrimaryStores) {
+        if (!fs.existsSync(store.path))
+            continue;
+        const dirs = getProjectDirs(store.path);
+        for (const dir of dirs) {
+            const projName = path.basename(dir);
+            storeProjects.push({ name: projName, store: store.name });
+        }
+    }
+    // Combine: primary projects (no store prefix) + non-primary (with store prefix)
+    const allProjects = [
+        ...primaryProjects.map((p) => ({ name: p, store: undefined })),
+        ...storeProjects,
+    ];
+    if (allProjects.length === 0)
         return mcpResponse({ ok: true, message: "No projects indexed.", data: { projects: [], total: 0 } });
-    const projects = projectRows.map(row => decodeStringRow(row, 1, "list_projects.projects")[0]);
     const pageSize = page_size ?? 20;
     const pageNum = page ?? 1;
     const start = Math.max(0, (pageNum - 1) * pageSize);
     const end = start + pageSize;
-    const pageProjects = projects.slice(start, end);
-    const totalPages = Math.max(1, Math.ceil(projects.length / pageSize));
+    const pageProjects = allProjects.slice(start, end);
+    const totalPages = Math.max(1, Math.ceil(allProjects.length / pageSize));
     if (pageNum > totalPages) {
         return mcpResponse({ ok: false, error: `Page ${pageNum} out of range. Total pages: ${totalPages}.` });
     }
     const badgeTypes = ["claude", "findings", "summary", "task"];
     const badgeLabels = { claude: "CLAUDE.md", findings: "FINDINGS", summary: "summary", task: "task" };
-    const projectList = pageProjects.map((proj) => {
-        const rows = queryDocRows(db, "SELECT project, filename, type, content, path FROM docs WHERE project = ?", [proj]) ?? [];
-        const types = rows.map(row => row.type);
-        const summaryRow = rows.find(row => row.type === "summary");
-        const claudeRow = rows.find(row => row.type === "claude");
-        const source = summaryRow?.content ?? claudeRow?.content;
-        let brief = "";
-        if (source) {
-            const firstLine = source.split("\n").find(l => l.trim() && !l.startsWith("#"));
-            brief = firstLine?.trim() || "";
+    const projectList = pageProjects.map((entry) => {
+        // Primary store projects: query the DB for badge info
+        if (!entry.store) {
+            const rows = queryDocRows(db, "SELECT project, filename, type, content, path FROM docs WHERE project = ?", [entry.name]) ?? [];
+            const types = rows.map(row => row.type);
+            const summaryRow = rows.find(row => row.type === "summary");
+            const claudeRow = rows.find(row => row.type === "claude");
+            const source = summaryRow?.content ?? claudeRow?.content;
+            let brief = "";
+            if (source) {
+                const firstLine = source.split("\n").find(l => l.trim() && !l.startsWith("#"));
+                brief = firstLine?.trim() || "";
+            }
+            const badges = badgeTypes.filter(t => types.includes(t)).map(t => badgeLabels[t]);
+            return { name: entry.name, store: undefined, brief, badges, fileCount: rows.length };
+        }
+        // Non-primary store projects: basic info (no DB query, just check file existence)
+        const store = nonPrimaryStores.find((s) => s.name === entry.store);
+        const projDir = store ? path.join(store.path, entry.name) : "";
+        const badges = [];
+        if (projDir) {
+            if (fs.existsSync(path.join(projDir, "CLAUDE.md")))
+                badges.push("CLAUDE.md");
+            if (fs.existsSync(path.join(projDir, "FINDINGS.md")))
+                badges.push("FINDINGS");
+            if (fs.existsSync(path.join(projDir, "summary.md")))
+                badges.push("summary");
+            if (fs.existsSync(path.join(projDir, "tasks.md")))
+                badges.push("task");
         }
-        const badges = badgeTypes.filter(t => types.includes(t)).map(t => badgeLabels[t]);
-        return { name: proj, brief, badges, fileCount: rows.length };
+        return { name: entry.name, store: entry.store, brief: "", badges, fileCount: badges.length };
     });
-    const lines = [`# Phren Projects (${projects.length})`];
+    const lines = [`# Phren Projects (${allProjects.length})`];
     if (profile)
         lines.push(`Profile: ${profile}`);
     lines.push(`Page: ${pageNum}/${totalPages} (page_size=${pageSize})`);
     lines.push(`Path: ${phrenPath}\n`);
     for (const p of projectList) {
-        lines.push(`## ${p.name}`);
+        const storeTag = p.store ? ` (${p.store})` : "";
+        lines.push(`## ${p.name}${storeTag}`);
         if (p.brief)
             lines.push(p.brief);
         lines.push(`[${p.badges.join(" | ")}] - ${p.fileCount} file(s)\n`);
@@ -537,7 +598,7 @@ async function handleListProjects(ctx, { page, page_size }) {
     return mcpResponse({
         ok: true,
         message: lines.join("\n"),
-        data: { projects: projectList, total: projects.length, page: pageNum, totalPages, pageSize },
+        data: { projects: projectList, total: allProjects.length, page: pageNum, totalPages, pageSize },
     });
 }
 async function handleGetFindings(ctx, { project, limit, include_superseded, include_history, status }) {

package/mcp/dist/tools/tasks.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";
@@ -207,10 +207,21 @@ export function register(server, ctx) {
             ]).describe("The task(s) to add. Pass a string for one task, or an array for bulk."),
             scope: z.string().optional().describe("Optional memory scope label. Defaults to 'shared'. Example: 'researcher' or 'builder'."),
         }),
-    }, async ({ project, item, scope }) => {
+    }, async ({ project: projectInput, item, scope }) => {
+        // Resolve store-qualified project names (e.g., "team/arc")
+        let targetPhrenPath;
+        let project;
+        try {
+            const resolved = resolveStoreForProject(ctx, projectInput);
+            targetPhrenPath = resolved.phrenPath;
+            project = resolved.project;
+        }
+        catch (err) {
+            return mcpResponse({ ok: false, error: err instanceof Error ? err.message : String(err) });
+        }
         if (!isValidProjectName(project))
             return mcpResponse({ ok: false, error: `Invalid project name: "${project}"` });
-        const addTaskDenied = permissionDeniedError(phrenPath, "add_task", project);
+        const addTaskDenied = permissionDeniedError(targetPhrenPath, "add_task", project);
         if (addTaskDenied)
             return mcpResponse({ ok: false, error: addTaskDenied });
         const normalizedScope = normalizeMemoryScope(scope ?? "shared");
@@ -218,20 +229,20 @@ export function register(server, ctx) {
             return mcpResponse({ ok: false, error: `Invalid scope: "${scope}". Use lowercase letters/numbers with '-' or '_' (max 64 chars), e.g. "researcher".` });
         if (Array.isArray(item)) {
             return withWriteQueue(async () => {
-                const result = addTasksBatch(phrenPath, project, item, { scope: normalizedScope });
+                const result = addTasksBatch(targetPhrenPath, project, item, { scope: normalizedScope });
                 if (!result.ok)
                     return mcpResponse({ ok: false, error: result.error });
                 const { added, errors } = result.data;
                 if (added.length > 0)
-                    refreshTaskIndex(updateFileInIndex, phrenPath, project);
+                    refreshTaskIndex(updateFileInIndex, targetPhrenPath, project);
                 return mcpResponse({ ok: added.length > 0, ...(added.length === 0 ? { error: `No tasks added: ${errors.join("; ")}` } : {}), message: `Added ${added.length} of ${item.length} tasks to ${project}`, data: { project, added, errors } });
             });
         }
         return withWriteQueue(async () => {
-            const result = addTaskStore(phrenPath, project, item, { scope: normalizedScope });
+            const result = addTaskStore(targetPhrenPath, project, item, { scope: normalizedScope });
             if (!result.ok)
                 return mcpResponse({ ok: false, error: result.error });
-            refreshTaskIndex(updateFileInIndex, phrenPath, project);
+            refreshTaskIndex(updateFileInIndex, targetPhrenPath, project);
             return mcpResponse({ ok: true, message: `Task added: ${result.data.line}`, data: { project, item, scope: normalizedScope } });
         });
     });

package/mcp/dist/tools/types.js

@@ -1,3 +1,25 @@
+import { parseStoreQualified } from "../store-routing.js";
+import { resolveAllStores } from "../store-registry.js";
+/**
+ * Resolve the effective phrenPath and bare project name for a project input.
+ * Handles store-qualified names ("store/project") by routing to the correct store.
+ * Returns the primary store path for bare names.
+ */
+export function resolveStoreForProject(ctx, projectInput) {
+    const { storeName, projectName } = parseStoreQualified(projectInput);
+    if (!storeName) {
+        return { phrenPath: ctx.phrenPath, project: projectName, storeRole: "primary" };
+    }
+    const stores = resolveAllStores(ctx.phrenPath);
+    const store = stores.find((s) => s.name === storeName);
+    if (!store) {
+        throw new Error(`Store "${storeName}" not found`);
+    }
+    if (store.role === "readonly") {
+        throw new Error(`Store "${storeName}" is read-only`);
+    }
+    return { phrenPath: store.path, project: projectName, storeRole: store.role };
+}
 /**
  * Convert an McpToolResult into the MCP SDK response format.
  * Single shared implementation — replaces the per-file jsonResponse() duplicates.

package/package.json

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