@phren/cli 0.0.42 → 0.0.44

package/mcp/dist/cli/actions.js

@@ -63,6 +63,29 @@ export async function handlePinCanonical(project, memory) {
     const result = upsertCanonical(getPhrenPath(), project, memory);
     console.log(result.ok ? result.data : result.error);
 }
+export async function handleTruths(project) {
+    if (!project) {
+        console.error("Usage: phren truths <project>");
+        process.exit(1);
+    }
+    const phrenPath = getPhrenPath();
+    const truthsPath = path.join(phrenPath, project, "truths.md");
+    if (!fs.existsSync(truthsPath)) {
+        console.log(`No truths pinned for "${project}" yet.`);
+        console.log(`\nPin one: phren pin ${project} "your truth here"`);
+        return;
+    }
+    const content = fs.readFileSync(truthsPath, "utf8");
+    const truths = content.split("\n").filter((line) => line.startsWith("- "));
+    if (truths.length === 0) {
+        console.log(`No truths pinned for "${project}" yet.`);
+        return;
+    }
+    console.log(`${truths.length} truth(s) for "${project}":\n`);
+    for (const truth of truths) {
+        console.log(`  ${truth}`);
+    }
+}
 export async function handleDoctor(args) {
     const profile = resolveRuntimeProfile(getPhrenPath());
     const fix = args.includes("--fix");
@@ -291,7 +314,7 @@ export async function handleUpdate(args) {
         process.exitCode = 1;
     }
     else {
-        console.log("Run 'npx phren init' to refresh hooks and config.");
+        console.log("Run 'phren init' to refresh hooks and config.");
     }
 }
 export async function handleReview(args) {

package/mcp/dist/cli/cli.js

@@ -8,8 +8,9 @@ import { handleGovernMemories, handlePruneMemories, handleConsolidateMemories, h
 import { handleConfig, handleIndexPolicy, handleRetentionPolicy, handleWorkflowPolicy, } from "./config.js";
 import { parseSearchArgs } from "./search.js";
 import { handleDetectSkills, handleFindingNamespace, handleHooksNamespace, handleProjectsNamespace, handleSkillsNamespace, handleSkillList, handlePromoteNamespace, handleStoreNamespace, handleTaskNamespace, } from "./namespaces.js";
+import { handleTeamNamespace } from "./team.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 { handleAddFinding, handleDoctor, handleFragmentSearch, handleMemoryUi, handleTruths, handlePinCanonical, handleQualityFeedback, handleRelatedDocs, handleReview, handleConsolidationStatus, handleSessionContext, handleSearch, handleShell, handleStatus, handleUpdate, } from "./actions.js";
 import { handleGraphNamespace } from "./graph.js";
 import { resolveRuntimeProfile } from "../runtime-profile.js";
 // ── CLI router ───────────────────────────────────────────────────────────────
@@ -107,8 +108,12 @@ export async function runCliCommand(command, args) {
             return handleConsolidationStatus(args);
         case "session-context":
             return handleSessionContext();
+        case "truths":
+            return handleTruths(args[0]);
         case "store":
             return handleStoreNamespace(args);
+        case "team":
+            return handleTeamNamespace(args);
         case "promote":
             return handlePromoteNamespace(args);
         default:

package/mcp/dist/cli/hooks-session.js

@@ -86,13 +86,13 @@ export function getUntrackedProjectNotice(phrenPath, cwd) {
     return [
         "<phren-notice>",
         "This project directory is not tracked by phren yet.",
-        "Run `npx phren add` to track it now.",
-        `Suggested command: \`npx phren add \"${projectDir}\"\``,
+        "Run `phren add` to track it now.",
+        `Suggested command: \`phren add \"${projectDir}\"\``,
         "Ask the user whether they want to add it to phren now.",
-        "If they say no, tell them they can always run `npx phren add` later.",
+        "If they say no, tell them they can always run `phren add` later.",
         "If they say yes, also ask whether phren should manage repo instruction files or leave their existing repo-owned CLAUDE/AGENTS files alone.",
-        `Then use the \`add_project\` MCP tool with path="${projectDir}" and ownership="phren-managed"|"detached"|"repo-managed", or run \`npx phren add\` from that directory.`,
-        "After onboarding, run `npx phren doctor` if hooks or MCP tools are not responding.",
+        `Then use the \`add_project\` MCP tool with path="${projectDir}" and ownership="phren-managed"|"detached"|"repo-managed", or run \`phren add\` from that directory.`,
+        "After onboarding, run `phren doctor` if hooks or MCP tools are not responding.",
         "<phren-notice>",
         "",
     ].join("\n");
@@ -127,8 +127,8 @@ export function getSessionStartOnboardingNotice(phrenPath, cwd, activeProject) {
         return [
             "<phren-notice>",
             "Phren onboarding: no tracked projects are active for this workspace yet.",
-            "Start in a project repo and run `npx phren add` so SessionStart can inject project context.",
-            "Run `npx phren doctor` to verify hooks and MCP wiring after setup.",
+            "Start in a project repo and run `phren add` so SessionStart can inject project context.",
+            "Run `phren doctor` to verify hooks and MCP wiring after setup.",
             "<phren-notice>",
             "",
         ].join("\n");
@@ -141,7 +141,7 @@ export function getSessionStartOnboardingNotice(phrenPath, cwd, activeProject) {
         "<phren-notice>",
         `Phren onboarding: project "${activeProject}" is tracked but memory is still empty.`,
         "Capture one finding with `add_finding` and one task with `add_task` to seed future SessionStart context.",
-        "Run `npx phren doctor` if setup seems incomplete.",
+        "Run `phren doctor` if setup seems incomplete.",
         "<phren-notice>",
         "",
     ].join("\n");

package/mcp/dist/cli/namespaces.js

@@ -594,7 +594,7 @@ export async function handleProjectsNamespace(args, profile) {
     }
     if (subcommand === "add") {
         console.error("`phren projects add` has been removed from the supported workflow.");
-        console.error("Use `cd ~/your-project && npx phren add` so enrollment stays path-based.");
+        console.error("Use `cd ~/your-project && phren add` so enrollment stays path-based.");
         process.exit(1);
     }
     if (subcommand === "remove") {
@@ -864,7 +864,7 @@ function handleProjectsList(profile) {
         .filter((name) => name !== "global")
         .sort();
     if (!projects.length) {
-        console.log("No projects found. Run: cd ~/your-project && npx phren add");
+        console.log("No projects found. Run: cd ~/your-project && phren add");
         return;
     }
     console.log(`\nProjects in ${phrenPath}:\n`);
@@ -888,7 +888,7 @@ function handleProjectsList(profile) {
         console.log(`  ${name}${tagStr}`);
     }
     console.log(`\n${projects.length} project(s) total.`);
-    console.log("Add another project: cd ~/your-project && npx phren add");
+    console.log("Add another project: cd ~/your-project && phren add");
 }
 async function handleProjectsRemove(name, profile) {
     if (!isValidProjectName(name)) {
@@ -1763,7 +1763,6 @@ export async function handlePromoteNamespace(args) {
     // 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) {

package/mcp/dist/cli/team.js

@@ -0,0 +1,301 @@
+/**
+ * Team store CLI commands: init, join, add-project.
+ * Creates and manages shared phren stores for team collaboration.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { execFileSync } from "child_process";
+import { getPhrenPath } from "../shared.js";
+import { isValidProjectName } from "../utils.js";
+import { addStoreToRegistry, findStoreByName, generateStoreId, readTeamBootstrap, updateStoreProjects, } from "../store-registry.js";
+const EXEC_TIMEOUT_MS = 30_000;
+function getOptionValue(args, name) {
+    const exactIdx = args.indexOf(name);
+    if (exactIdx !== -1)
+        return args[exactIdx + 1];
+    const prefixed = args.find((arg) => arg.startsWith(`${name}=`));
+    return prefixed ? prefixed.slice(name.length + 1) : undefined;
+}
+function getPositionalArgs(args, optionNames) {
+    const positions = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (optionNames.includes(arg)) {
+            i++;
+            continue;
+        }
+        if (optionNames.some((name) => arg.startsWith(`${name}=`)))
+            continue;
+        if (!arg.startsWith("--"))
+            positions.push(arg);
+    }
+    return positions;
+}
+function atomicWriteText(filePath, content) {
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    const tmp = filePath + ".tmp." + process.pid;
+    fs.writeFileSync(tmp, content);
+    fs.renameSync(tmp, filePath);
+}
+// ── phren team init <name> [--remote <url>] [--description <desc>] ──────────
+async function handleTeamInit(args) {
+    const phrenPath = getPhrenPath();
+    const positional = getPositionalArgs(args, ["--remote", "--description"]);
+    const name = positional[0];
+    const remote = getOptionValue(args, "--remote");
+    const description = getOptionValue(args, "--description");
+    if (!name) {
+        console.error("Usage: phren team init <name> [--remote <url>] [--description <text>]");
+        process.exit(1);
+    }
+    if (!isValidProjectName(name)) {
+        console.error(`Invalid store name: "${name}". Use lowercase letters, numbers, hyphens.`);
+        process.exit(1);
+    }
+    // Check if store already exists
+    const existing = findStoreByName(phrenPath, name);
+    if (existing) {
+        console.error(`Store "${name}" already exists at ${existing.path}`);
+        process.exit(1);
+    }
+    const storesDir = path.join(path.dirname(phrenPath), ".phren-stores");
+    const storePath = path.join(storesDir, name);
+    if (fs.existsSync(storePath)) {
+        console.error(`Directory already exists: ${storePath}`);
+        process.exit(1);
+    }
+    // Create the team store directory
+    fs.mkdirSync(storePath, { recursive: true });
+    // Write .phren-team.yaml
+    const bootstrap = {
+        name,
+        description: description || `${name} team knowledge`,
+        default_role: "team",
+    };
+    atomicWriteText(path.join(storePath, ".phren-team.yaml"), `name: ${bootstrap.name}\ndescription: ${bootstrap.description}\ndefault_role: team\n`);
+    // Write .gitignore
+    atomicWriteText(path.join(storePath, ".gitignore"), ".runtime/\n.sessions/\n*.lock\n");
+    // Create global directory with starter files
+    const globalDir = path.join(storePath, "global");
+    fs.mkdirSync(globalDir, { recursive: true });
+    atomicWriteText(path.join(globalDir, "CLAUDE.md"), `# ${name} Team Store\n\nShared knowledge for the ${name} team.\n`);
+    atomicWriteText(path.join(globalDir, "FINDINGS.md"), `# global findings\n`);
+    // Initialize git repo
+    execFileSync("git", ["init"], {
+        cwd: storePath,
+        stdio: "pipe",
+        timeout: EXEC_TIMEOUT_MS,
+    });
+    // Initial commit
+    execFileSync("git", ["add", "-A"], { cwd: storePath, stdio: "pipe", timeout: EXEC_TIMEOUT_MS });
+    execFileSync("git", ["commit", "-m", "phren: initialize team store"], {
+        cwd: storePath,
+        stdio: "pipe",
+        timeout: EXEC_TIMEOUT_MS,
+    });
+    // Add remote if provided
+    if (remote) {
+        execFileSync("git", ["remote", "add", "origin", remote], {
+            cwd: storePath,
+            stdio: "pipe",
+            timeout: EXEC_TIMEOUT_MS,
+        });
+        try {
+            execFileSync("git", ["push", "-u", "origin", "main"], {
+                cwd: storePath,
+                stdio: "pipe",
+                timeout: EXEC_TIMEOUT_MS,
+            });
+            console.log(`  Pushed to ${remote}`);
+        }
+        catch {
+            // Try HEAD branch name
+            try {
+                execFileSync("git", ["push", "-u", "origin", "HEAD"], {
+                    cwd: storePath,
+                    stdio: "pipe",
+                    timeout: EXEC_TIMEOUT_MS,
+                });
+                console.log(`  Pushed to ${remote}`);
+            }
+            catch {
+                console.log(`  Remote added but push failed. Push manually: cd ${storePath} && git push -u origin main`);
+            }
+        }
+    }
+    // Register in primary store's stores.yaml
+    const entry = {
+        id: generateStoreId(),
+        name,
+        path: storePath,
+        role: "team",
+        sync: "managed-git",
+        ...(remote ? { remote } : {}),
+    };
+    addStoreToRegistry(phrenPath, entry);
+    console.log(`\nCreated team store: ${name}`);
+    console.log(`  Path: ${storePath}`);
+    console.log(`  Role: team`);
+    console.log(`  ID: ${entry.id}`);
+    if (!remote) {
+        console.log(`\nNext: add a remote and push`);
+        console.log(`  cd ${storePath}`);
+        console.log(`  git remote add origin <your-git-url>`);
+        console.log(`  git push -u origin main`);
+    }
+    console.log(`\nAdd projects: phren team add-project ${name} <project-name>`);
+}
+// ── phren team join <url> [--name <name>] ───────────────────────────────────
+async function handleTeamJoin(args) {
+    const phrenPath = getPhrenPath();
+    const positional = getPositionalArgs(args, ["--name"]);
+    const remote = positional[0];
+    const nameOverride = getOptionValue(args, "--name");
+    if (!remote) {
+        console.error("Usage: phren team join <git-url> [--name <name>]");
+        process.exit(1);
+    }
+    const storesDir = path.join(path.dirname(phrenPath), ".phren-stores");
+    // Infer name from URL if not provided
+    const inferredName = nameOverride || path.basename(remote, ".git").toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+    if (!isValidProjectName(inferredName)) {
+        console.error(`Invalid store name: "${inferredName}". Use --name to specify a valid name.`);
+        process.exit(1);
+    }
+    const existing = findStoreByName(phrenPath, inferredName);
+    if (existing) {
+        console.error(`Store "${inferredName}" already exists at ${existing.path}`);
+        process.exit(1);
+    }
+    const storePath = path.join(storesDir, inferredName);
+    if (fs.existsSync(storePath)) {
+        console.error(`Directory already exists: ${storePath}`);
+        process.exit(1);
+    }
+    // Clone the remote
+    console.log(`Cloning ${remote}...`);
+    fs.mkdirSync(storesDir, { recursive: true });
+    execFileSync("git", ["clone", "--", remote, storePath], {
+        stdio: "inherit",
+        timeout: 60_000,
+    });
+    // Read .phren-team.yaml if present
+    const bootstrap = readTeamBootstrap(storePath);
+    const finalName = bootstrap?.name || inferredName;
+    const finalRole = bootstrap?.default_role === "primary" ? "team" : (bootstrap?.default_role || "team");
+    const entry = {
+        id: generateStoreId(),
+        name: finalName,
+        path: storePath,
+        role: finalRole,
+        sync: finalRole === "readonly" ? "pull-only" : "managed-git",
+        remote,
+    };
+    addStoreToRegistry(phrenPath, entry);
+    console.log(`\nJoined team store: ${finalName}`);
+    console.log(`  Path: ${storePath}`);
+    console.log(`  Role: ${finalRole}`);
+    console.log(`  ID: ${entry.id}`);
+    if (bootstrap?.description) {
+        console.log(`  Description: ${bootstrap.description}`);
+    }
+}
+// ── phren team add-project <store> <project> ────────────────────────────────
+async function handleTeamAddProject(args) {
+    const phrenPath = getPhrenPath();
+    const positional = getPositionalArgs(args, []);
+    const storeName = positional[0];
+    const projectName = positional[1];
+    if (!storeName || !projectName) {
+        console.error("Usage: phren team add-project <store-name> <project-name>");
+        process.exit(1);
+    }
+    if (!isValidProjectName(projectName)) {
+        console.error(`Invalid project name: "${projectName}"`);
+        process.exit(1);
+    }
+    const store = findStoreByName(phrenPath, storeName);
+    if (!store) {
+        console.error(`Store "${storeName}" not found. Run 'phren store list' to see available stores.`);
+        process.exit(1);
+    }
+    if (store.role === "readonly") {
+        console.error(`Store "${storeName}" is read-only. Cannot add projects.`);
+        process.exit(1);
+    }
+    // Create project directory in the store
+    const projectDir = path.join(store.path, projectName);
+    const journalDir = path.join(projectDir, "journal");
+    fs.mkdirSync(journalDir, { recursive: true });
+    // Scaffold project files
+    if (!fs.existsSync(path.join(projectDir, "FINDINGS.md"))) {
+        atomicWriteText(path.join(projectDir, "FINDINGS.md"), `# ${projectName} findings\n`);
+    }
+    if (!fs.existsSync(path.join(projectDir, "tasks.md"))) {
+        atomicWriteText(path.join(projectDir, "tasks.md"), `# ${projectName} tasks\n\n## Active\n\n## Queue\n\n## Done\n`);
+    }
+    if (!fs.existsSync(path.join(projectDir, "summary.md"))) {
+        atomicWriteText(path.join(projectDir, "summary.md"), `# ${projectName}\n**What:** \n`);
+    }
+    // Update store's project claims in registry
+    const currentProjects = store.projects || [];
+    if (!currentProjects.includes(projectName)) {
+        updateStoreProjects(phrenPath, storeName, [...currentProjects, projectName]);
+    }
+    console.log(`Added project "${projectName}" to team store "${storeName}"`);
+    console.log(`  Path: ${projectDir}`);
+    console.log(`  Journal: ${journalDir}`);
+    console.log(`\nWrites to "${projectName}" will now route to "${storeName}" automatically.`);
+}
+// ── phren team list ─────────────────────────────────────────────────────────
+async function handleTeamList() {
+    const phrenPath = getPhrenPath();
+    const { resolveAllStores } = await import("../store-registry.js");
+    const stores = resolveAllStores(phrenPath);
+    const teamStores = stores.filter((s) => s.role === "team");
+    if (teamStores.length === 0) {
+        console.log("No team stores registered.");
+        console.log("\nCreate one:  phren team init <name> [--remote <url>]");
+        console.log("Join one:    phren team join <git-url>");
+        return;
+    }
+    console.log(`${teamStores.length} team store(s):\n`);
+    for (const store of teamStores) {
+        const exists = fs.existsSync(store.path);
+        console.log(`  ${store.name} (${store.id}) ${exists ? "" : "[missing]"}`);
+        console.log(`    path: ${store.path}`);
+        if (store.remote)
+            console.log(`    remote: ${store.remote}`);
+        if (store.projects?.length)
+            console.log(`    projects: ${store.projects.join(", ")}`);
+        console.log();
+    }
+}
+// ── Entry point ─────────────────────────────────────────────────────────────
+export async function handleTeamNamespace(args) {
+    const subcommand = args[0];
+    const subArgs = args.slice(1);
+    switch (subcommand) {
+        case "init":
+            return handleTeamInit(subArgs);
+        case "join":
+            return handleTeamJoin(subArgs);
+        case "add-project":
+            return handleTeamAddProject(subArgs);
+        case "list":
+            return handleTeamList();
+        default:
+            console.log(`phren team — manage shared team stores
+
+  phren team init <name> [--remote <url>]     Create a new team store
+  phren team join <git-url> [--name <name>]   Join an existing team store
+  phren team add-project <store> <project>    Add a project to a team store
+  phren team list                             List team stores
+`);
+            if (subcommand) {
+                console.error(`Unknown subcommand: ${subcommand}`);
+                process.exit(1);
+            }
+    }
+}

package/mcp/dist/cli-hooks-session-handlers.js

@@ -60,13 +60,13 @@ export function getUntrackedProjectNotice(phrenPath, cwd) {
     return [
         "<phren-notice>",
         "This project directory is not tracked by phren yet.",
-        "Run `npx phren add` to track it now.",
-        `Suggested command: \`npx phren add "${projectDir}"\``,
+        "Run `phren add` to track it now.",
+        `Suggested command: \`phren add "${projectDir}"\``,
         "Ask the user whether they want to add it to phren now.",
-        "If they say no, tell them they can always run `npx phren add` later.",
+        "If they say no, tell them they can always run `phren add` later.",
         "If they say yes, also ask whether phren should manage repo instruction files or leave their existing repo-owned CLAUDE/AGENTS files alone.",
-        `Then use the \`add_project\` MCP tool with path="${projectDir}" and ownership="phren-managed"|"detached"|"repo-managed", or run \`npx phren add\` from that directory.`,
-        "After onboarding, run `npx phren doctor` if hooks or MCP tools are not responding.",
+        `Then use the \`add_project\` MCP tool with path="${projectDir}" and ownership="phren-managed"|"detached"|"repo-managed", or run \`phren add\` from that directory.`,
+        "After onboarding, run `phren doctor` if hooks or MCP tools are not responding.",
         "<phren-notice>",
         "",
     ].join("\n");
@@ -83,8 +83,8 @@ export function getSessionStartOnboardingNotice(phrenPath, cwd, activeProject) {
         return [
             "<phren-notice>",
             "Phren onboarding: no tracked projects are active for this workspace yet.",
-            "Start in a project repo and run `npx phren add` so SessionStart can inject project context.",
-            "Run `npx phren doctor` to verify hooks and MCP wiring after setup.",
+            "Start in a project repo and run `phren add` so SessionStart can inject project context.",
+            "Run `phren doctor` to verify hooks and MCP wiring after setup.",
             "<phren-notice>",
             "",
         ].join("\n");
@@ -97,7 +97,7 @@ export function getSessionStartOnboardingNotice(phrenPath, cwd, activeProject) {
         "<phren-notice>",
         `Phren onboarding: project "${activeProject}" is tracked but memory is still empty.`,
         "Capture one finding with `add_finding` and one task with `add_task` to seed future SessionStart context.",
-        "Run `npx phren doctor` if setup seems incomplete.",
+        "Run `phren doctor` if setup seems incomplete.",
         "<phren-notice>",
         "",
     ].join("\n");
@@ -273,6 +273,24 @@ export async function handleHookSessionStart() {
     catch (err) {
         logger.debug("hookSessionStart trackSession", errorMessage(err));
     }
+    // Pull non-primary stores (team + readonly) so session starts with fresh data
+    try {
+        const { getNonPrimaryStores } = await import("./store-registry.js");
+        const otherStores = getNonPrimaryStores(phrenPath);
+        for (const store of otherStores) {
+            if (!fs.existsSync(store.path) || !fs.existsSync(path.join(store.path, ".git")))
+                continue;
+            try {
+                await runBestEffortGit(["pull", "--rebase", "--quiet"], store.path);
+            }
+            catch (err) {
+                debugLog(`session-start store-pull ${store.name}: ${errorMessage(err)}`);
+            }
+        }
+    }
+    catch {
+        // store-registry not available — skip silently
+    }
     updateRuntimeHealth(phrenPath, {
         lastSessionStartAt: startedAt,
         lastSync: {

package/mcp/dist/cli-hooks-stop.js

@@ -485,18 +485,48 @@ export async function handleHookStop() {
         });
         appendAuditLog(phrenPath, "hook_stop", `status=saved-local detail=${JSON.stringify(syncDetail)}`);
     }); // end withFileLock(gitOpLockPath)
-    // Pull non-primary stores (best-effort, non-blocking)
+    // Sync non-primary stores: commit+push team stores, pull-only readonly stores
     try {
         const { getNonPrimaryStores } = await import("./store-registry.js");
         const otherStores = getNonPrimaryStores(phrenPath);
         for (const store of otherStores) {
             if (!fs.existsSync(store.path) || !fs.existsSync(path.join(store.path, ".git")))
                 continue;
-            try {
-                await runBestEffortGit(["pull", "--rebase", "--quiet"], store.path);
+            if (store.role === "team") {
+                // Team stores: stage team-safe files, commit, and push
+                try {
+                    const storeStatus = await runBestEffortGit(["status", "--porcelain"], store.path);
+                    if (storeStatus.ok && storeStatus.output) {
+                        // Only stage journal/, tasks.md, truths.md, FINDINGS.md, summary.md — NOT .runtime/
+                        await runBestEffortGit(["add", "--", "*/journal/*", "*/tasks.md", "*/truths.md", "*/FINDINGS.md", "*/summary.md", ".phren-team.yaml"], store.path);
+                        const actor = process.env.PHREN_ACTOR || process.env.USER || "unknown";
+                        const teamCommit = await runBestEffortGit(["commit", "-m", `phren: ${actor} team sync`], store.path);
+                        if (teamCommit.ok) {
+                            // Check for remote before pushing
+                            const storeRemotes = await runBestEffortGit(["remote"], store.path);
+                            if (storeRemotes.ok && storeRemotes.output?.trim()) {
+                                const teamPush = await runBestEffortGit(["push"], store.path);
+                                if (!teamPush.ok) {
+                                    // Try pull-rebase then push
+                                    await runBestEffortGit(["pull", "--rebase", "--quiet"], store.path);
+                                    await runBestEffortGit(["push"], store.path);
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    debugLog(`hook-stop team-store-sync ${store.name}: ${errorMessage(err)}`);
+                }
             }
-            catch (err) {
-                debugLog(`hook-stop store-pull ${store.name}: ${errorMessage(err)}`);
+            else {
+                // Readonly stores: pull only
+                try {
+                    await runBestEffortGit(["pull", "--rebase", "--quiet"], store.path);
+                }
+                catch (err) {
+                    debugLog(`hook-stop store-pull ${store.name}: ${errorMessage(err)}`);
+                }
             }
         }
     }

package/mcp/dist/content/dedup.js

@@ -338,12 +338,15 @@ export function isDuplicateFinding(existingContent, newLearning, threshold = 0.6
             return true;
         }
         // Second pass: Jaccard similarity (strip metadata before comparing)
+        // Threshold lowered from 0.55 to 0.40 to catch agent paraphrases —
+        // swarm agents often report the same insight with different wording,
+        // and 0.55 let too many through.
         const newTokens = jaccardTokenize(stripMetadata(newLearning));
         const existingTokens = jaccardTokenize(stripMetadata(bullet));
         if (newTokens.size < 3 || existingTokens.size < 3)
             continue; // too few tokens for reliable Jaccard
         const jaccard = jaccardSimilarity(newTokens, existingTokens);
-        if (jaccard > 0.55) {
+        if (jaccard > 0.40) {
             debugLog(`duplicate-detection: Jaccard ${Math.round(jaccard * 100)}% with existing: "${bullet.slice(0, 80)}"`);
             return true;
         }
@@ -489,7 +492,7 @@ export async function checkSemanticDedup(phrenPath, project, newLearning, signal
         if (tokA.size < 3 || tokB.size < 3)
             continue;
         const jaccard = jaccardSimilarity(tokA, tokB);
-        if (jaccard >= 0.55)
+        if (jaccard >= 0.40)
             continue; // already caught by sync isDuplicateFinding
         if (jaccard >= 0.3) {
             const isDup = await semanticDedup(a, b, phrenPath, signal);

package/mcp/dist/entrypoint.js

@@ -87,6 +87,12 @@ const HELP_TOPICS = {
   phren store add <name> --remote <url>   Add a team store
   phren store remove <name>               Remove a store (local only)
   phren store sync                        Pull all stores
+`,
+    team: `Team:
+  phren team init <name> [--remote <url>]     Create a new team store
+  phren team join <git-url> [--name <name>]   Join an existing team store
+  phren team add-project <store> <project>    Add a project to a team store
+  phren team list                             List team stores
 `,
     env: `Environment variables:
   PHREN_PATH                  Override phren directory (default: ~/.phren)
@@ -174,7 +180,9 @@ const CLI_COMMANDS = [
     "review",
     "consolidation-status",
     "session-context",
+    "truths",
     "store",
+    "team",
     "promote",
 ];
 async function flushTopLevelOutput() {
@@ -265,7 +273,7 @@ export async function runTopLevelCommand(argv) {
         const phrenPath = defaultPhrenPath();
         const profile = (process.env.PHREN_PROFILE) || undefined;
         if (!fs.existsSync(phrenPath) || !fs.existsSync(path.join(phrenPath, ".config"))) {
-            console.log("phren is not set up yet. Run: npx phren init");
+            console.log("phren is not set up yet. Run: phren init");
             return finish(1);
         }
         const ownership = ownershipArg
@@ -381,7 +389,7 @@ export async function runTopLevelCommand(argv) {
             const note = getVerifyOutcomeNote(phrenPath, result.checks);
             if (note)
                 console.log(`\nNote: ${note}`);
-            console.log(`\nRun \`npx phren init\` to fix setup issues.`);
+            console.log(`\nRun \`phren init\` to fix setup issues.`);
         }
         return finish(result.ok ? 0 : 1);
     }
@@ -408,7 +416,7 @@ export async function runTopLevelCommand(argv) {
         }
     }
     if (argvCommand === "link") {
-        console.error("`phren link` has been removed. Use `npx phren init` instead.");
+        console.error("`phren link` has been removed. Use `phren init` instead.");
         return finish(1);
     }
     if (argvCommand === "--health") {

package/mcp/dist/finding/context.js

@@ -167,6 +167,7 @@ export function resolveFindingSessionId(phrenPath, project, explicitSessionId) {
         .sort((a, b) => sessionSortValue(b) - sessionSortValue(a));
     if (matchingProject.length > 0)
         return matchingProject[0].sessionId;
-    const sorted = active.sort((a, b) => sessionSortValue(b) - sessionSortValue(a));
-    return sorted[0]?.sessionId;
+    // Do not attribute findings to an unrelated active session from another project.
+    // Missing session provenance is safer than cross-project contamination.
+    return undefined;
 }

package/mcp/dist/init/config.js

@@ -207,7 +207,7 @@ export function configureClaude(phrenPath, opts = {}) {
                 eventHooks.push({ matcher: "", hooks: [hookBody] });
             }
         };
-        const toolHookEnabled = hooksEnabled && isFeatureEnabled("PHREN_FEATURE_TOOL_HOOK", false);
+        const toolHookEnabled = hooksEnabled && isFeatureEnabled("PHREN_FEATURE_TOOL_HOOK", true);
         if (hooksEnabled) {
             upsertPhrenHook("UserPromptSubmit", {
                 type: "command",