@phren/cli 0.1.11 → 0.1.13

package/dist/cli/hooks-session.js

@@ -428,8 +428,13 @@ async function runBestEffortGit(args, cwd) {
 }
 async function countUnsyncedCommits(cwd) {
     const upstream = await runBestEffortGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd);
-    if (!upstream.ok || !upstream.output)
-        return 0;
+    if (!upstream.ok || !upstream.output) {
+        const allCommits = await runBestEffortGit(["rev-list", "--count", "HEAD"], cwd);
+        if (!allCommits.ok || !allCommits.output)
+            return 0;
+        const parsed = Number.parseInt(allCommits.output.trim(), 10);
+        return Number.isNaN(parsed) ? 0 : parsed;
+    }
     const ahead = await runBestEffortGit(["rev-list", "--count", `${upstream.output.trim()}..HEAD`], cwd);
     if (!ahead.ok || !ahead.output)
         return 0;

package/dist/cli/namespaces.js

@@ -1719,6 +1719,26 @@ export async function handleStoreNamespace(args) {
                     stdio: "pipe",
                     timeout: 30_000,
                 });
+                // Re-apply sparse-checkout after pull on primary store to avoid materializing all files
+                if (store.role === "primary") {
+                    try {
+                        const sparseList = execFileSync("git", ["sparse-checkout", "list"], {
+                            cwd: store.path,
+                            stdio: "pipe",
+                            timeout: 10_000,
+                        }).toString().trim();
+                        if (sparseList) {
+                            execFileSync("git", ["sparse-checkout", "reapply"], {
+                                cwd: store.path,
+                                stdio: "pipe",
+                                timeout: 10_000,
+                            });
+                        }
+                    }
+                    catch {
+                        // sparse-checkout not configured — nothing to reapply
+                    }
+                }
                 console.log(`  ${store.name}: ok`);
             }
             catch (err) {

package/dist/cli/team.js

@@ -7,6 +7,7 @@ import * as path from "path";
 import { execFileSync } from "child_process";
 import { getPhrenPath } from "../shared.js";
 import { isValidProjectName } from "../utils.js";
+import { addProjectToProfile, resolveActiveProfile } from "../profile-store.js";
 import { addStoreToRegistry, findStoreByName, generateStoreId, readTeamBootstrap, updateStoreProjects, } from "../store-registry.js";
 const EXEC_TIMEOUT_MS = 30_000;
 function getOptionValue(args, name) {
@@ -243,6 +244,17 @@ async function handleTeamAddProject(args) {
     if (!currentProjects.includes(projectName)) {
         updateStoreProjects(phrenPath, storeName, [...currentProjects, projectName]);
     }
+    // Add project to active profile so it's visible to profile-filtered operations
+    const activeProfile = resolveActiveProfile(phrenPath);
+    if (activeProfile.ok && activeProfile.data) {
+        const addResult = addProjectToProfile(phrenPath, activeProfile.data, projectName);
+        if (!addResult.ok) {
+            throw new Error(addResult.error);
+        }
+    }
+    else if (!activeProfile.ok && activeProfile.code !== "FILE_NOT_FOUND") {
+        throw new Error(activeProfile.error);
+    }
     console.log(`Added project "${projectName}" to team store "${storeName}"`);
     console.log(`  Path: ${projectDir}`);
     console.log(`  Journal: ${journalDir}`);

package/dist/cli-hooks-git.js

@@ -123,8 +123,15 @@ export async function runBestEffortGit(args, cwd) {
 }
 export async function countUnsyncedCommits(cwd) {
     const upstream = await runBestEffortGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd);
-    if (!upstream.ok || !upstream.output)
-        return 0;
+    if (!upstream.ok || !upstream.output) {
+        // No upstream tracking branch — count all local commits as unsynced
+        // so the warning at the call site fires instead of silently returning 0
+        const allCommits = await runBestEffortGit(["rev-list", "--count", "HEAD"], cwd);
+        if (!allCommits.ok || !allCommits.output)
+            return 0;
+        const parsed = Number.parseInt(allCommits.output.trim(), 10);
+        return Number.isNaN(parsed) ? 0 : parsed;
+    }
     const ahead = await runBestEffortGit(["rev-list", "--count", `${upstream.output.trim()}..HEAD`], cwd);
     if (!ahead.ok || !ahead.output)
         return 0;

package/dist/cli-hooks-stop.js

@@ -435,32 +435,20 @@ export async function handleHookStop() {
             return;
         }
         // Check if HEAD has an upstream tracking branch before attempting sync.
-        // Detached HEAD or branches without upstream would cause silent push failures.
+        // If no upstream is set but a remote exists, auto-set it to avoid silent push failures.
         const upstream = await runBestEffortGit(["rev-parse", "--abbrev-ref", "@{upstream}"], phrenPath);
         if (!upstream.ok || !upstream.output) {
-            const unsyncedCommits = await countUnsyncedCommits(phrenPath);
-            const noUpstreamDetail = "commit created; no upstream tracking branch";
-            finalizeTaskSession({
-                phrenPath,
-                sessionId: taskSessionId,
-                status: "no-upstream",
-                detail: noUpstreamDetail,
-            });
-            updateRuntimeHealth(phrenPath, {
-                lastStopAt: now,
-                lastAutoSave: { at: now, status: "no-upstream", detail: noUpstreamDetail },
-                lastSync: {
-                    lastPushAt: now,
-                    lastPushStatus: "no-upstream",
-                    lastPushDetail: noUpstreamDetail,
-                    unsyncedCommits,
-                },
-            });
-            appendAuditLog(phrenPath, "hook_stop", "status=no-upstream");
-            if (unsyncedCommits > 3) {
-                process.stderr.write(`phren: ${unsyncedCommits} unsynced commits — no upstream tracking branch.\n`);
+            // Try to auto-set upstream: get current branch and set tracking to origin/<branch>
+            const branch = await runBestEffortGit(["rev-parse", "--abbrev-ref", "HEAD"], phrenPath);
+            if (branch.ok && branch.output) {
+                const branchName = branch.output.trim();
+                const setUpstream = await runBestEffortGit(["branch", "--set-upstream-to", `origin/${branchName}`, branchName], phrenPath);
+                if (!setUpstream.ok) {
+                    // Upstream auto-set failed — log and continue to sync anyway
+                    logger.debug("hookStop", `failed to auto-set upstream for ${branchName}`);
+                }
             }
-            return;
+            // Fall through to scheduleBackgroundSync instead of returning early
         }
         const unsyncedCommits = await countUnsyncedCommits(phrenPath);
         const scheduled = scheduleBackgroundSync(phrenPath);

package/dist/profile-store.js

@@ -310,8 +310,19 @@ export function listProjectCards(phrenPath, profile) {
     const dirs = getProjectDirs(phrenPath, profile).sort((a, b) => path.basename(a).localeCompare(path.basename(b)));
     const cards = dirs.map(buildProjectCard);
     const seen = new Set(dirs.map((d) => path.basename(d)));
-    // Include projects from team stores
+    // Include projects from team stores, filtered by active profile
     try {
+        // Resolve the profile's project allow-list (if any)
+        let profileProjectNames;
+        if (profile) {
+            const profiles = listProfiles(phrenPath);
+            if (profiles.ok) {
+                const active = profiles.data.find((p) => p.name === profile);
+                if (active && active.projects.length > 0) {
+                    profileProjectNames = new Set(active.projects);
+                }
+            }
+        }
         for (const store of getNonPrimaryStores(phrenPath)) {
             if (!fs.existsSync(store.path))
                 continue;
@@ -319,6 +330,8 @@ export function listProjectCards(phrenPath, profile) {
                 const name = path.basename(dir);
                 if (seen.has(name) || name === "global")
                     continue;
+                if (profileProjectNames && !profileProjectNames.has(name))
+                    continue;
                 seen.add(name);
                 cards.push(buildProjectCard(dir));
             }

package/dist/shared/index.js

@@ -30,12 +30,30 @@ async function refreshStoreProjectDirs(phrenPath, profile) {
     try {
         const { getNonPrimaryStores, getStoreProjectDirs } = await import("../store-registry.js");
         const otherStores = getNonPrimaryStores(phrenPath);
-        const dirs = [];
+        let dirs = [];
         for (const store of otherStores) {
             if (!fs.existsSync(store.path))
                 continue;
             dirs.push(...getStoreProjectDirs(store));
         }
+        // Filter by active profile's project list, matching getProjectDirs behavior
+        if (profile) {
+            const profilePath = path.join(phrenPath, "profiles", `${profile}.yaml`);
+            if (fs.existsSync(profilePath)) {
+                try {
+                    const yaml = await import("js-yaml");
+                    const data = yaml.load(fs.readFileSync(profilePath, "utf-8"), { schema: yaml.CORE_SCHEMA });
+                    const projects = data?.projects;
+                    if (Array.isArray(projects)) {
+                        const allowed = new Set(projects.map(String));
+                        dirs = dirs.filter(dir => allowed.has(path.basename(dir)));
+                    }
+                }
+                catch {
+                    // Profile parse error — include all dirs as fallback
+                }
+            }
+        }
         _cachedStoreProjectDirs = dirs;
         _cachedStorePhrenPath = phrenPath;
     }
@@ -445,8 +463,9 @@ function globAllFiles(phrenPath, profile) {
     const allAbsolutePaths = [];
     for (const dir of projectDirs) {
         const projectName = path.basename(dir);
-        const config = readProjectConfig(phrenPath, projectName);
-        const ownership = getProjectOwnershipMode(phrenPath, projectName, config);
+        const storePath = path.dirname(dir);
+        const config = readProjectConfig(storePath, projectName);
+        const ownership = getProjectOwnershipMode(storePath, projectName, config);
         const mdFilesSet = new Set();
         for (const pattern of indexPolicy.includeGlobs) {
             const dot = indexPolicy.includeHidden || pattern.startsWith(".") || pattern.includes("/.");

package/dist/shared/retrieval.js

@@ -495,20 +495,21 @@ export async function searchKnowledgeRows(db, options) {
  * Returns an array of results tagged with their source store. Read-only — no mutations.
  */
 export async function searchFederatedStores(localPhrenPath, options) {
-    let nonPrimaryStores;
+    // Registered non-primary stores are already included in the main FTS index
+    // by buildIndex (via refreshStoreProjectDirs). Only search unregistered
+    // federation paths from PHREN_FEDERATION_PATHS to avoid double indexing.
+    let registeredStorePaths;
     try {
         const { getNonPrimaryStores } = await import("../store-registry.js");
-        nonPrimaryStores = getNonPrimaryStores(localPhrenPath).map((s) => ({
-            path: s.path, name: s.name, id: s.id,
-        }));
+        registeredStorePaths = new Set(getNonPrimaryStores(localPhrenPath).map((s) => s.path));
     }
     catch {
-        // Fallback: parse PHREN_FEDERATION_PATHS directly (pre-registry compat)
-        const raw = process.env.PHREN_FEDERATION_PATHS ?? "";
-        nonPrimaryStores = raw.split(":").map((p) => p.trim())
-            .filter((p) => p.length > 0 && p !== localPhrenPath && fs.existsSync(p))
-            .map((p) => ({ path: p, name: path.basename(p), id: "" }));
+        registeredStorePaths = new Set();
     }
+    const raw = process.env.PHREN_FEDERATION_PATHS ?? "";
+    const nonPrimaryStores = raw.split(":").map((p) => p.trim())
+        .filter((p) => p.length > 0 && p !== localPhrenPath && !registeredStorePaths.has(p) && fs.existsSync(p))
+        .map((p) => ({ path: p, name: path.basename(p), id: "" }));
     if (nonPrimaryStores.length === 0)
         return [];
     const allRows = [];

package/dist/tools/ops.js

@@ -10,16 +10,48 @@ import { addProjectFromPath } from "../core/project.js";
 import { PROJECT_OWNERSHIP_MODES, parseProjectOwnershipMode } from "../project-config.js";
 import { resolveRuntimeProfile } from "../runtime-profile.js";
 import { getMachineName } from "../machine-identity.js";
+import { resolveAllStores } from "../store-registry.js";
 import { getProjectConsolidationStatus, CONSOLIDATION_ENTRY_THRESHOLD } from "../content/validate.js";
 import { logger } from "../logger.js";
 import { getRuntimeHealth } from "../governance/policy.js";
 import { countUnsyncedCommits } from "../cli-hooks-git.js";
 // ── Handlers ─────────────────────────────────────────────────────────────────
-async function handleAddProject(ctx, { path: targetPath, profile: requestedProfile, ownership }) {
+async function handleAddProject(ctx, { path: targetPath, profile: requestedProfile, ownership, store: storeName }) {
     const { phrenPath, profile, withWriteQueue } = ctx;
     return withWriteQueue(async () => {
         try {
-            const added = addProjectFromPath(phrenPath, targetPath, requestedProfile || profile || undefined, parseProjectOwnershipMode(ownership) ?? undefined);
+            // Resolve the target store path: explicit store > auto-route by project claim > primary
+            let targetPhrenPath = phrenPath;
+            let storeRole = "primary";
+            if (storeName) {
+                const stores = resolveAllStores(phrenPath);
+                const store = stores.find((s) => s.name === storeName);
+                if (!store) {
+                    return mcpResponse({ ok: false, error: `Store "${storeName}" not found` });
+                }
+                if (store.role === "readonly") {
+                    return mcpResponse({ ok: false, error: `Store "${storeName}" is read-only` });
+                }
+                targetPhrenPath = store.path;
+                storeRole = store.role;
+            }
+            else {
+                // Check if any non-primary writable store claims this project
+                const projectName = targetPath
+                    ? path.basename(path.resolve(targetPath)).toLowerCase().replace(/[^a-z0-9_-]/g, "-")
+                    : undefined;
+                if (projectName) {
+                    const stores = resolveAllStores(phrenPath);
+                    for (const store of stores) {
+                        if (store.role !== "readonly" && store.role !== "primary" && store.projects?.includes(projectName)) {
+                            targetPhrenPath = store.path;
+                            storeRole = store.role;
+                            break;
+                        }
+                    }
+                }
+            }
+            const added = addProjectFromPath(targetPhrenPath, targetPath, requestedProfile || profile || undefined, parseProjectOwnershipMode(ownership) ?? undefined);
             if (!added.ok) {
                 return mcpResponse({
                     ok: false,
@@ -29,7 +61,9 @@ async function handleAddProject(ctx, { path: targetPath, profile: requestedProfi
             await ctx.rebuildIndex();
             return mcpResponse({
                 ok: true,
-                message: `Added project "${added.data.project}" (${added.data.ownership}) from ${added.data.path}.`,
+                message: `Added project "${added.data.project}" (${added.data.ownership}) from ${added.data.path}` +
+                    (storeRole !== "primary" ? ` [store: ${storeName || storeRole}]` : "") +
+                    `.`,
                 data: added.data,
             });
         }
@@ -419,6 +453,8 @@ export function register(server, ctx) {
             profile: z.string().optional().describe("Profile to update. Defaults to the active profile."),
             ownership: z.enum(PROJECT_OWNERSHIP_MODES).optional()
                 .describe("How Phren should treat repo-facing instruction files: phren-managed, detached, or repo-managed."),
+            store: z.string().optional()
+                .describe("Target store name (from stores.yaml). If omitted, auto-routes to the store that claims this project, or falls back to the primary store."),
         }),
     }, (params) => handleAddProject(ctx, params));
     server.registerTool("health_check", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phren/cli",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Knowledge layer for AI agents — CLI, MCP server, and data layer",
   "type": "module",
   "bin": {