@phren/cli 0.0.50 → 0.0.52

package/mcp/dist/phren-core.js

@@ -7,7 +7,7 @@
  * tools (React, Django, Unity, JUCE, Ansible, ...) are learned dynamically from
  * each project's FINDINGS.md via extractDynamicEntities().
  */
-export const UNIVERSAL_TECH_TERMS_RE = /\b(Python|Rust|Go|Java|TypeScript|JavaScript|Docker|Kubernetes|AWS|GCP|Azure|SQL|Git)\b/gi;
+export const UNIVERSAL_TECH_TERMS_RE = /\b(Python|Rust|Go|Java|TypeScript|JavaScript|Docker|Kubernetes|AWS|GCP|Azure|SQL|Git|React|Vue|Angular|Svelte|Next\.?js|Nuxt|Vite|esbuild|Webpack|Rollup|Babel|ESLint|Biome|Prettier|Jest|Vitest|Playwright|Cypress|Node\.?js|Deno|Bun|Express|Fastify|Hono|Koa|NestJS|Prisma|Drizzle|Sequelize|TypeORM|Postgres|PostgreSQL|MySQL|SQLite|MongoDB|Redis|Elasticsearch|GraphQL|REST|gRPC|tRPC|Zod|Pydantic|FastAPI|Django|Flask|Rails|Spring|Laravel|Tailwind|Bootstrap|MUI|Material|Fluent|Chakra|Radix|shadcn|SharePoint|SPFx|Teams|OneDrive|Power\s*Apps|Deltek|VantagePoint|Hangfire|ASP\.?NET|MVC|Blazor|MAUI|Electron|VSCode|GitHub|GitLab|Bitbucket|Vercel|Netlify|Railway|Fly\.io|Cloudflare|Lambda|S3|EC2|RDS|DynamoDB|Stripe|Twilio|SendGrid|OpenAI|Anthropic|Claude|LLM|MCP|FTS5|SQLCipher|Sigma|ForceAtlas|Graphology|Playwright|Puppeteer|Selenium|Turbo|Turborepo|Lerna|nx|pnpm|yarn|npm|Bun)\b/gi;
 /**
  * Additional fragment patterns beyond CamelCase and acronyms.
  * Each pattern has a named group so callers can identify the fragment type.

package/mcp/dist/profile-store.js

@@ -305,6 +305,26 @@ function buildProjectCard(dir) {
 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
+    try {
+        const storeRegistry = require("./store-registry.js");
+        const { getNonPrimaryStores } = storeRegistry;
+        for (const store of getNonPrimaryStores(phrenPath)) {
+            if (!fs.existsSync(store.path))
+                continue;
+            for (const dir of getProjectDirs(store.path)) {
+                const name = path.basename(dir);
+                if (seen.has(name) || name === "global")
+                    continue;
+                seen.add(name);
+                cards.push(buildProjectCard(dir));
+            }
+        }
+    }
+    catch {
+        // store-registry not available or error loading, continue with primary only
+    }
     // Prepend global as a pinned entry so it's always accessible from the shell
     const globalDir = path.join(phrenPath, "global");
     if (fs.existsSync(globalDir)) {

package/mcp/dist/project-config.js

@@ -130,6 +130,32 @@ export function isProjectHookEnabled(phrenPath, project, event, config) {
         return hooks.enabled;
     return true;
 }
+/**
+ * Remove a per-project hook override, restoring inheritance from global config.
+ * Pass event to clear a specific event override; omit to clear the whole hooks block.
+ */
+export function clearProjectHookOverride(phrenPath, project, event) {
+    const configPath = resolveProjectConfigPath(phrenPath, project);
+    if (!configPath)
+        throw new Error("Project config path escapes phren store");
+    return withFileLock(configPath, () => {
+        const current = readProjectConfig(phrenPath, project);
+        const existingHooks = normalizeHookConfig(current);
+        let nextHooks;
+        if (event && PROJECT_HOOK_EVENTS.includes(event)) {
+            // Delete just this event key
+            const { [event]: _removed, ...rest } = existingHooks;
+            nextHooks = rest;
+        }
+        else {
+            // Clear all overrides
+            nextHooks = {};
+        }
+        const next = { ...current, hooks: nextHooks };
+        writeProjectConfigFile(configPath, next);
+        return next;
+    });
+}
 export function writeProjectHookConfig(phrenPath, project, patch) {
     // Move read+merge inside the lock so concurrent writers cannot clobber each other.
     const configPath = resolveProjectConfigPath(phrenPath, project);

package/mcp/dist/shared/index.js

@@ -34,7 +34,7 @@ async function refreshStoreProjectDirs(phrenPath, profile) {
         for (const store of otherStores) {
             if (!fs.existsSync(store.path))
                 continue;
-            dirs.push(...getProjectDirs(store.path, profile));
+            dirs.push(...getProjectDirs(store.path));
         }
         _cachedStoreProjectDirs = dirs;
         _cachedStorePhrenPath = phrenPath;

package/mcp/dist/shell/view.js

@@ -5,6 +5,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import { canonicalTaskFilePath, listProjectCards, readTasks, readFindings, readReviewQueue, readRuntimeHealth, resolveTaskFilePath, } from "../data/access.js";
+import { getNonPrimaryStores } from "../store-registry.js";
 import { style, badge, separator, stripAnsi, truncateLine, renderWidth, wrapSegments, lineViewport, shellHelpText, gradient, } from "./render.js";
 import { formatSelectableLine, viewportWithStatus, } from "./view-list.js";
 import { SUB_VIEWS, TAB_ICONS, } from "./types.js";
@@ -15,6 +16,19 @@ import { isProjectHookEnabled, readProjectConfig } from "../project-config.js";
 import { getScopedSkills } from "../skill/registry.js";
 import { errorMessage } from "../utils.js";
 import { logger } from "../logger.js";
+/** Resolve which store (primary or team) contains a project */
+function resolveProjectStorePath(phrenPath, project) {
+    if (fs.existsSync(path.join(phrenPath, project)))
+        return phrenPath;
+    try {
+        for (const store of getNonPrimaryStores(phrenPath)) {
+            if (fs.existsSync(path.join(store.path, project)))
+                return store.path;
+        }
+    }
+    catch { /* fall through */ }
+    return phrenPath;
+}
 // ── Tab bar ────────────────────────────────────────────────────────────────
 function renderTabBar(state) {
     const cols = renderWidth();
@@ -108,9 +122,10 @@ function collectProjectDashboardEntries(ctx) {
                 reviewCount: 0,
             };
         }
-        const task = readTasks(ctx.phrenPath, card.name);
-        const findings = readFindings(ctx.phrenPath, card.name);
-        const review = readReviewQueue(ctx.phrenPath, card.name);
+        const storePath = resolveProjectStorePath(ctx.phrenPath, card.name);
+        const task = readTasks(storePath, card.name);
+        const findings = readFindings(storePath, card.name);
+        const review = readReviewQueue(storePath, card.name);
         return {
             ...card,
             activeCount: task.ok ? task.data.items.Active.length : 0,
@@ -262,16 +277,17 @@ function renderTaskView(ctx, cursor, height, subsectionsCache) {
     if (!project) {
         return { lines: [style.dim("  No project selected — navigate to Projects (← →) and press ↵")], subsectionsCache };
     }
-    const result = readTasks(ctx.phrenPath, project);
+    const storePath = resolveProjectStorePath(ctx.phrenPath, project);
+    const result = readTasks(storePath, project);
     if (!result.ok)
         return { lines: [result.error], subsectionsCache };
     const parsed = result.data;
     const warnings = parsed.issues.length
         ? [`  ${style.yellow("⚠")}  ${style.yellow(parsed.issues.join("; "))}`, ""]
         : [];
-    const taskFile = resolveTaskFilePath(ctx.phrenPath, project)
-        ?? canonicalTaskFilePath(ctx.phrenPath, project)
-        ?? path.join(ctx.phrenPath, project, "tasks.md");
+    const taskFile = resolveTaskFilePath(storePath, project)
+        ?? canonicalTaskFilePath(storePath, project)
+        ?? path.join(storePath, project, "tasks.md");
     const subsResult = parseSubsections(taskFile, project, subsectionsCache);
     const subsections = subsResult.map;
     const newCache = subsResult.cache;
@@ -341,7 +357,8 @@ function renderFindingsView(ctx, cursor, height) {
     const project = ctx.state.project;
     if (!project)
         return [style.dim("  No project selected.")];
-    const result = readFindings(ctx.phrenPath, project);
+    const storePath = resolveProjectStorePath(ctx.phrenPath, project);
+    const result = readFindings(storePath, project);
     if (!result.ok)
         return [result.error];
     const all = result.data;
@@ -390,7 +407,8 @@ function renderMemoryQueueView(ctx, cursor, height) {
     const project = ctx.state.project;
     if (!project)
         return [style.dim("  No project selected.")];
-    const result = readReviewQueue(ctx.phrenPath, project);
+    const storePath = resolveProjectStorePath(ctx.phrenPath, project);
+    const result = readReviewQueue(storePath, project);
     if (!result.ok)
         return [result.error];
     const filtered = ctx.state.filter

package/mcp/dist/store-routing.js

@@ -85,7 +85,7 @@ export function listAllProjects(phrenPath, profile) {
     const stores = resolveAllStores(phrenPath);
     const results = [];
     for (const store of stores) {
-        const dirs = getProjectDirs(store.path, profile);
+        const dirs = getProjectDirs(store.path, store.role === "primary" ? profile : undefined);
         for (const dir of dirs) {
             const projectName = path.basename(dir);
             results.push({ store, projectName, projectDir: dir });
@@ -101,7 +101,7 @@ function isValidStoreName(name) {
 function findProjectInStore(store, projectName, profile) {
     if (!fs.existsSync(store.path))
         return null;
-    const dirs = getProjectDirs(store.path, profile);
+    const dirs = getProjectDirs(store.path, store.role === "primary" ? profile : undefined);
     for (const dir of dirs) {
         if (path.basename(dir) === projectName)
             return dir;

package/mcp/dist/task/lifecycle.js

@@ -9,6 +9,12 @@ import { incrementSessionTasksCompleted } from "../tools/session.js";
 const ACTION_PREFIX_RE = /^(?:please\s+|can you\s+|could you\s+|would you\s+|i want you to\s+|i want to\s+|let(?:'|’)s\s+|lets\s+|help me\s+)/i;
 const EXPLICIT_TASK_PREFIX_RE = /^(?:add(?:\s+(?:this|that|it))?\s+(?:to\s+(?:the\s+)?)?(?:task|todo(?:\s+list)?|task(?:\s+list)?)|add\s+(?:a\s+)?task|put(?:\s+(?:this|that|it))?\s+(?:in|on)\s+(?:the\s+)?(?:task|todo(?:\s+list)?|task(?:\s+list)?))\s*(?::|-|,)?\s*/i;
 const NON_ACTIONABLE_RE = /\b(brainstorm|idea|ideas|maybe|what if|should we|could we|would it make sense|question|explain|why is|how does)\b/i;
+// Conversational noise: only matches when the ENTIRE prompt is a short ack/reaction (under 40 chars).
+// This avoids rejecting "sure, go ahead and fix the build" or "great, now update the docs".
+const CONVERSATIONAL_NOISE_RE = /^(ok|okay|yeah|yep|nah|nope|hi|hey|ss|bro|lol|lmao|got it|sounds good|perfect|great|sure|thanks|thank you|ty|np|no problem|alright|cool|nice|damn|wtf|omg|fok)[\s!.?,]*$/i;
+// Raw system/SQL error fragment signals — patterns that only appear in error output, never real task requests.
+// Intentionally does NOT include "line \d+" or "incorrect syntax" alone (too broad — they appear in dev prompts).
+const RAW_MESSAGE_SIGNALS_RE = /\b(msg \d+, level \d+|cannot insert the value null|insufficient result space|uniqueidentifier value to char|pgevision-prod|task-notification|tool-use-id|toolu_0[a-z0-9])\b/i;
 const ACTIONABLE_RE = /\b(add|build|change|complete|continue|create|delete|fix|implement|improve|investigate|make|move|refactor|remove|rename|repair|ship|start|update|wire)\b/i;
 const CONTINUE_RE = /\b(continue|keep going|finish|resume|pick up|work on that|that task)\b/i;
 const GITHUB_URL_RE = /https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/issues\/\d+(?:[?#][^\s]*)?/g;
@@ -89,6 +95,11 @@ function isActionablePrompt(prompt, intent) {
         return false;
     if (NON_ACTIONABLE_RE.test(normalized))
         return false;
+    // Always reject conversational noise and raw system/SQL fragments regardless of intent.
+    if (CONVERSATIONAL_NOISE_RE.test(normalized))
+        return false;
+    if (RAW_MESSAGE_SIGNALS_RE.test(normalized))
+        return false;
     if (intent === "general")
         return ACTIONABLE_RE.test(normalized);
     return true;

package/mcp/dist/tools/config.js

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
-import { mcpResponse } from "./types.js";
+import { mcpResponse, resolveStoreForProject } from "./types.js";
 import { z } from "zod";
 import { getRetentionPolicy, updateRetentionPolicy, getWorkflowPolicy, updateWorkflowPolicy, getIndexPolicy, updateIndexPolicy, mergeConfig, VALID_TASK_MODES, VALID_FINDING_SENSITIVITY, } from "../shared/governance.js";
 import { PROACTIVITY_LEVELS, } from "../proactivity.js";
@@ -75,7 +75,16 @@ async function handleGetConfig(ctx, { domain, project }) {
         const err = validateProject(project);
         if (err)
             return mcpResponse({ ok: false, error: err });
-        const topicResult = getTopicConfigData(phrenPath, project);
+        // Resolve store-qualified project names for team stores
+        let resolvedPhrenPath = phrenPath;
+        let resolvedProject = project;
+        try {
+            const resolved = resolveStoreForProject(ctx, project);
+            resolvedPhrenPath = resolved.phrenPath;
+            resolvedProject = resolved.project;
+        }
+        catch { /* fall back to primary */ }
+        const topicResult = getTopicConfigData(resolvedPhrenPath, resolvedProject);
         if (!topicResult.ok)
             return mcpResponse({ ok: false, error: topicResult.error });
         return mcpResponse({
@@ -445,9 +454,18 @@ async function handleSetConfig(ctx, { domain, settings, project }) {
             const err = validateProject(project);
             if (err)
                 return mcpResponse({ ok: false, error: err });
-            const projectDir = safeProjectPath(phrenPath, project);
+            // Resolve store-qualified project names for team stores
+            let topicPhrenPath = phrenPath;
+            let topicProject = project;
+            try {
+                const resolved = resolveStoreForProject(ctx, project);
+                topicPhrenPath = resolved.phrenPath;
+                topicProject = resolved.project;
+            }
+            catch { /* fall back to primary */ }
+            const projectDir = safeProjectPath(topicPhrenPath, topicProject);
             if (!projectDir || !fs.existsSync(projectDir)) {
-                return mcpResponse({ ok: false, error: `Project "${project}" not found in phren.` });
+                return mcpResponse({ ok: false, error: `Project "${topicProject}" not found in phren.` });
             }
             const topics = settings.topics;
             if (!topics || !Array.isArray(topics)) {
@@ -480,7 +498,7 @@ async function handleSetConfig(ctx, { domain, settings, project }) {
                     fs.writeFileSync(configPath, JSON.stringify({ version: 1, domain: topicDomain, topics: [] }, null, 2) + "\n");
                 }
             }
-            const result = writeProjectTopics(phrenPath, project, normalized);
+            const result = writeProjectTopics(topicPhrenPath, topicProject, normalized);
             if (!result.ok) {
                 return mcpResponse({ ok: false, error: result.error });
             }

package/mcp/dist/tools/data.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";
@@ -35,10 +35,21 @@ export function register(server, ctx) {
         inputSchema: z.object({
             project: z.string().describe("Project name to export."),
         }),
-    }, async ({ project }) => {
+    }, async ({ project: projectInput }) => {
+        // Resolve store-qualified project names (e.g. "qualus-shared/arc")
+        let resolvedPhrenPath;
+        let project;
+        try {
+            const resolved = resolveStoreForProject(ctx, projectInput);
+            resolvedPhrenPath = 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 projectDir = safeProjectPath(phrenPath, project);
+        const projectDir = safeProjectPath(resolvedPhrenPath, project);
         if (!projectDir || !fs.existsSync(projectDir) || !fs.statSync(projectDir).isDirectory()) {
             return mcpResponse({ ok: false, error: `Project "${project}" not found.` });
         }
@@ -46,17 +57,16 @@ export function register(server, ctx) {
         const summaryPath = safeProjectPath(projectDir, "summary.md");
         if (summaryPath && fs.existsSync(summaryPath))
             exported.summary = fs.readFileSync(summaryPath, "utf8");
-        const learningsResult = readFindings(phrenPath, project);
+        const learningsResult = readFindings(resolvedPhrenPath, project);
         if (learningsResult.ok)
             exported.learnings = learningsResult.data;
         const findingsPath = safeProjectPath(projectDir, "FINDINGS.md");
         if (findingsPath && fs.existsSync(findingsPath))
             exported.findingsRaw = fs.readFileSync(findingsPath, "utf8");
-        const taskResult = readTasks(phrenPath, project);
+        const taskResult = readTasks(resolvedPhrenPath, project);
         if (taskResult.ok) {
             exported.task = taskResult.data.items;
-            // Also export the raw task file string for lossless round-trip (preserves priority/pinned/stable IDs)
-            const taskRawPath = resolveTaskFilePath(phrenPath, project);
+            const taskRawPath = resolveTaskFilePath(resolvedPhrenPath, project);
             if (taskRawPath && fs.existsSync(taskRawPath))
                 exported.taskRaw = fs.readFileSync(taskRawPath, "utf8");
         }

package/mcp/dist/tools/extract.js

@@ -1,4 +1,4 @@
-import { mcpResponse } from "./types.js";
+import { mcpResponse, resolveStoreForProject } from "./types.js";
 import { z } from "zod";
 import { isValidProjectName, safeProjectPath, errorMessage } from "../utils.js";
 import { addFindingsToFile } from "../shared/content.js";
@@ -39,7 +39,7 @@ function parseFindings(raw) {
     return [];
 }
 export function register(server, ctx) {
-    const { phrenPath, withWriteQueue, updateFileInIndex } = ctx;
+    const { withWriteQueue, updateFileInIndex } = ctx;
     server.registerTool("auto_extract_findings", {
         title: "◆ phren · auto-extract findings",
         description: "Use a local Ollama LLM to automatically extract non-obvious findings from text. " +
@@ -53,7 +53,10 @@ export function register(server, ctx) {
             model: z.string().optional().describe("Ollama model to use (overrides PHREN_EXTRACT_MODEL env var)."),
             dryRun: z.boolean().optional().describe("If true, return what would be extracted without saving."),
         }),
-    }, async ({ project, text, model, dryRun }) => {
+    }, async ({ project: projectInput, text, model, dryRun }) => {
+        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}"` });
         }
@@ -112,14 +115,14 @@ export function register(server, ctx) {
         return withWriteQueue(async () => {
             // Use addFindingsToFile so extracted findings go through the full pipeline:
             // secret scan, dedup check, validation, and index update.
-            const result = addFindingsToFile(phrenPath, project, findings, { source: "extract" });
+            const result = addFindingsToFile(targetPath, project, findings, { source: "extract" });
             if (!result.ok) {
                 return mcpResponse({ ok: false, error: result.error });
             }
             const { added, skipped, rejected } = result.data;
             const allSkipped = [...skipped, ...rejected.map(r => r.text)];
             // Update index for the findings file
-            const resolvedDir = safeProjectPath(phrenPath, project);
+            const resolvedDir = safeProjectPath(targetPath, project);
             if (resolvedDir) {
                 updateFileInIndex(path.join(resolvedDir, "FINDINGS.md"));
             }

package/mcp/dist/tools/finding.js

@@ -5,7 +5,7 @@ import * as path from "path";
 import { logger } from "../logger.js";
 import { isValidProjectName, safeProjectPath, errorMessage } from "../utils.js";
 import { removeFinding as removeFindingCore, removeFindings as removeFindingsCore, } from "../core/finding.js";
-import { debugLog, EXEC_TIMEOUT_MS, FINDING_TYPES, normalizeMemoryScope, RESERVED_PROJECT_DIR_NAMES, } from "../shared.js";
+import { debugLog, EXEC_TIMEOUT_MS, FINDING_TYPES, normalizeMemoryScope, } from "../shared.js";
 import { addFindingToFile, addFindingsToFile, checkSemanticConflicts, autoMergeConflicts, } from "../shared/content.js";
 import { jaccardTokenize, jaccardSimilarity, stripMetadata } from "../content/dedup.js";
 import { runCustomHooks } from "../hooks.js";
@@ -330,17 +330,22 @@ async function handleResolveContradiction(ctx, { project: projectInput, finding_
     }));
 }
 async function handleGetContradictions(ctx, { project, finding_text }) {
-    const { phrenPath } = ctx;
     if (project && !isValidProjectName(project))
         return mcpResponse({ ok: false, error: `Invalid project name: "${project}"` });
-    const projects = project
-        ? [project]
-        : fs.readdirSync(phrenPath, { withFileTypes: true })
-            .filter((entry) => entry.isDirectory() && !RESERVED_PROJECT_DIR_NAMES.has(entry.name) && isValidProjectName(entry.name))
-            .map((entry) => entry.name);
+    // Build project list from all stores (primary + team)
+    let projectsWithPaths;
+    if (project) {
+        const resolved = resolveStoreForProject(ctx, project);
+        projectsWithPaths = [{ project: resolved.project, storePath: resolved.phrenPath }];
+    }
+    else {
+        const { listAllProjects } = await import("../store-routing.js");
+        projectsWithPaths = listAllProjects(ctx.phrenPath, ctx.profile)
+            .map((p) => ({ project: p.projectName, storePath: p.store.path }));
+    }
     const contradictions = [];
-    for (const p of projects) {
-        const result = readFindings(phrenPath, p);
+    for (const { project: p, storePath } of projectsWithPaths) {
+        const result = readFindings(storePath, p);
         if (!result.ok)
             continue;
         for (const finding of result.data) {

package/mcp/dist/tools/graph.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 crypto from "crypto";
@@ -85,7 +85,13 @@ export function register(server, ctx) {
         }
         const results = [];
         for (const doc of relatedDocs) {
-            const docRow = queryDocBySourceKey(db, ctx.phrenPath, doc);
+            const docProject = doc.split("/")[0];
+            let docPhrenPath = ctx.phrenPath;
+            try {
+                docPhrenPath = resolveStoreForProject(ctx, docProject).phrenPath;
+            }
+            catch { /* fall back to primary */ }
+            const docRow = queryDocBySourceKey(db, docPhrenPath, doc);
             const snippet = docRow?.content ? docRow.content.slice(0, 200) : "";
             results.push({ sourceDoc: doc, snippet });
         }
@@ -255,7 +261,10 @@ export function register(server, ctx) {
             catch (err) {
                 logger.debug("graph", `link_findings globalFragments: ${errorMessage(err)}`);
             }
-            // 4b. Persist manual link so it survives index rebuilds (mandatory — failure aborts the operation)
+            // 4b. Persist manual link so it survives index rebuilds (mandatory — failure aborts the operation).
+            // Note: manual-links.json is intentionally written to the primary phrenPath's runtime directory.
+            // During index rebuild, it's read and merged into the unified index (which includes team store docs),
+            // so team store projects' manual links persist and are queryable cross-store. Writes are always to primary.
             const manualLinksPath = runtimeFile(ctx.phrenPath, "manual-links.json");
             try {
                 withFileLock(manualLinksPath, () => {

package/mcp/dist/tools/hooks.js

@@ -5,7 +5,7 @@ import * as path from "path";
 import { readInstallPreferences, updateInstallPreferences } from "../init/preferences.js";
 import { readCustomHooks, getHookTarget, HOOK_EVENT_VALUES, validateCustomHookCommand, validateCustomWebhookUrl } from "../hooks.js";
 import { hookConfigPath } from "../shared.js";
-import { PROJECT_HOOK_EVENTS, isProjectHookEnabled, readProjectConfig, writeProjectHookConfig } from "../project-config.js";
+import { PROJECT_HOOK_EVENTS, isProjectHookEnabled, readProjectConfig, writeProjectHookConfig, clearProjectHookOverride } from "../project-config.js";
 import { isValidProjectName } from "../utils.js";
 const HOOK_TOOLS = ["claude", "copilot", "cursor", "codex"];
 const VALID_CUSTOM_EVENTS = HOOK_EVENT_VALUES;
@@ -97,14 +97,27 @@ export function register(server, ctx) {
         description: "Enable or disable hooks globally, for a specific tool, or for a tracked project.",
         inputSchema: z.object({
             enabled: z.boolean().describe("true to enable, false to disable."),
+            clear: z.boolean().optional().describe("When true and project is set, removes the per-project override and restores inheritance from global. Ignores enabled."),
             tool: z.string().optional().describe("Specific tool. Omit to toggle globally."),
             project: z.string().optional().describe("Tracked project name for project-level lifecycle hook overrides."),
             event: z.string().optional().describe("Optional lifecycle event for project-level overrides: UserPromptSubmit, Stop, SessionStart, PostToolUse."),
         }),
-    }, async ({ enabled, tool, project, event }) => {
+    }, async ({ enabled, clear, tool, project, event }) => {
         if (tool && project) {
             return mcpResponse({ ok: false, error: "Pass either tool or project, not both." });
         }
+        // Clear per-project override (restore inheritance)
+        if (clear && project) {
+            if (!isValidProjectName(project) || !fs.existsSync(path.join(phrenPath, project))) {
+                return mcpResponse({ ok: false, error: `Project "${project}" not found.` });
+            }
+            clearProjectHookOverride(phrenPath, project, event);
+            const scope = event ? `${event} hook` : "hooks";
+            return mcpResponse({ ok: true, message: `Cleared ${scope} override for ${project} — now inheriting from global.`, data: { project, event, cleared: true } });
+        }
+        if (clear) {
+            return mcpResponse({ ok: false, error: "clear requires project." });
+        }
         if (event && !project) {
             return mcpResponse({ ok: false, error: "event requires project." });
         }

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"}`,