@phren/cli 0.0.42 → 0.0.44

package/mcp/dist/tools/finding.js

@@ -17,8 +17,8 @@ import { getActiveTaskForSession } from "../task/lifecycle.js";
 import { FINDING_PROVENANCE_SOURCES } from "../content/citation.js";
 import { isInactiveFindingLine, supersedeFinding, retractFinding as retractFindingLifecycle, resolveFindingContradiction, } from "../finding/lifecycle.js";
 import { permissionDeniedError } from "../governance/rbac.js";
-const JACCARD_MAYBE_LOW = 0.30;
-const JACCARD_MAYBE_HIGH = 0.55; // above this isDuplicateFinding already catches it
+const JACCARD_MAYBE_LOW = 0.25;
+const JACCARD_MAYBE_HIGH = 0.40; // above this isDuplicateFinding already catches it
 function findJaccardCandidates(phrenPath, project, finding) {
     try {
         const findingsPath = path.join(phrenPath, project, "FINDINGS.md");
@@ -263,22 +263,52 @@ async function handleAddFinding(ctx, params) {
         }
     });
 }
-async function handleSupersedeFinding(ctx, { project, finding_text, superseded_by }) {
-    const { phrenPath, withWriteQueue, updateFileInIndex } = ctx;
+async function handleSupersedeFinding(ctx, { project: projectInput, finding_text, superseded_by }) {
+    let phrenPath;
+    let project;
+    try {
+        const resolved = resolveStoreForProject(ctx, projectInput);
+        phrenPath = resolved.phrenPath;
+        project = resolved.project;
+    }
+    catch (err) {
+        return mcpResponse({ ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+    const { withWriteQueue, updateFileInIndex } = ctx;
     return withLifecycleMutation(phrenPath, project, withWriteQueue, updateFileInIndex, () => supersedeFinding(phrenPath, project, finding_text, superseded_by), (data) => ({
         message: `Marked finding as superseded in ${project}.`,
         data: { project, finding: data.finding, status: data.status, superseded_by: data.superseded_by },
     }));
 }
-async function handleRetractFinding(ctx, { project, finding_text, reason }) {
-    const { phrenPath, withWriteQueue, updateFileInIndex } = ctx;
+async function handleRetractFinding(ctx, { project: projectInput, finding_text, reason }) {
+    let phrenPath;
+    let project;
+    try {
+        const resolved = resolveStoreForProject(ctx, projectInput);
+        phrenPath = resolved.phrenPath;
+        project = resolved.project;
+    }
+    catch (err) {
+        return mcpResponse({ ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+    const { withWriteQueue, updateFileInIndex } = ctx;
     return withLifecycleMutation(phrenPath, project, withWriteQueue, updateFileInIndex, () => retractFindingLifecycle(phrenPath, project, finding_text, reason), (data) => ({
         message: `Retracted finding in ${project}.`,
         data: { project, finding: data.finding, status: data.status, reason: data.reason },
     }));
 }
-async function handleResolveContradiction(ctx, { project, finding_text, finding_text_other, finding_a, finding_b, resolution }) {
-    const { phrenPath, withWriteQueue, updateFileInIndex } = ctx;
+async function handleResolveContradiction(ctx, { project: projectInput, finding_text, finding_text_other, finding_a, finding_b, resolution }) {
+    let phrenPath;
+    let project;
+    try {
+        const resolved = resolveStoreForProject(ctx, projectInput);
+        phrenPath = resolved.phrenPath;
+        project = resolved.project;
+    }
+    catch (err) {
+        return mcpResponse({ ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+    const { withWriteQueue, updateFileInIndex } = ctx;
     const findingText = (finding_text ?? finding_a)?.trim();
     const findingTextOther = (finding_text_other ?? finding_b)?.trim();
     if (!findingText || !findingTextOther) {
@@ -342,8 +372,18 @@ async function handleGetContradictions(ctx, { project, finding_text }) {
         },
     });
 }
-async function handleEditFinding(ctx, { project, old_text, new_text }) {
-    const { phrenPath, withWriteQueue, updateFileInIndex } = ctx;
+async function handleEditFinding(ctx, { project: projectInput, old_text, new_text }) {
+    let phrenPath;
+    let project;
+    try {
+        const resolved = resolveStoreForProject(ctx, projectInput);
+        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 editDenied = permissionDeniedError(phrenPath, "edit_finding", project);
@@ -363,8 +403,18 @@ async function handleEditFinding(ctx, { project, old_text, new_text }) {
         });
     });
 }
-async function handleRemoveFinding(ctx, { project, finding }) {
-    const { phrenPath, withWriteQueue, updateFileInIndex } = ctx;
+async function handleRemoveFinding(ctx, { project: projectInput, finding }) {
+    let phrenPath;
+    let project;
+    try {
+        const resolved = resolveStoreForProject(ctx, projectInput);
+        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 removeDenied = permissionDeniedError(phrenPath, "remove_finding", project);
@@ -494,6 +544,58 @@ async function handlePushChanges(ctx, { message }) {
         catch (err) {
             return mcpResponse({ ok: false, error: `Save failed: ${errorMessage(err)}`, errorCode: "INTERNAL_ERROR" });
         }
+        // Sync team stores: commit and push journal/tasks/truths changes
+        try {
+            const { getNonPrimaryStores } = await import("../store-registry.js");
+            const teamStores = getNonPrimaryStores(phrenPath).filter((s) => s.role === "team");
+            const teamResults = [];
+            for (const store of teamStores) {
+                if (!fs.existsSync(store.path) || !fs.existsSync(path.join(store.path, ".git")))
+                    continue;
+                const runStoreGit = (args, opts = {}) => execFileSync("git", args, {
+                    cwd: store.path,
+                    encoding: "utf8",
+                    timeout: opts.timeout ?? EXEC_TIMEOUT_MS,
+                    env: opts.env,
+                    stdio: ["ignore", "pipe", "pipe"],
+                }).trim();
+                try {
+                    const storeStatus = runStoreGit(["status", "--porcelain"]);
+                    if (!storeStatus) {
+                        teamResults.push({ store: store.name, pushed: false });
+                        continue;
+                    }
+                    // Only stage team-safe files: journal/, tasks.md, truths.md, FINDINGS.md, summary.md
+                    runStoreGit(["add", "--", "*/journal/*", "*/tasks.md", "*/truths.md", "*/FINDINGS.md", "*/summary.md"]);
+                    const actor = process.env.PHREN_ACTOR || process.env.USER || "unknown";
+                    runStoreGit(["commit", "-m", `phren: ${actor} team sync`]);
+                    try {
+                        runStoreGit(["push"], { timeout: 15000 });
+                        teamResults.push({ store: store.name, pushed: true });
+                    }
+                    catch {
+                        try {
+                            runStoreGit(["pull", "--rebase", "--quiet"], { timeout: 15000 });
+                            runStoreGit(["push"], { timeout: 15000 });
+                            teamResults.push({ store: store.name, pushed: true });
+                        }
+                        catch (retryErr) {
+                            teamResults.push({ store: store.name, pushed: false, error: errorMessage(retryErr) });
+                        }
+                    }
+                }
+                catch (storeErr) {
+                    teamResults.push({ store: store.name, pushed: false, error: errorMessage(storeErr) });
+                }
+            }
+            // Team store results are best-effort — don't fail the primary push for them
+            if (teamResults.length > 0) {
+                debugLog(`push_changes team stores: ${JSON.stringify(teamResults)}`);
+            }
+        }
+        catch {
+            // store-registry not available — skip silently
+        }
     });
 }
 // ── Registration ─────────────────────────────────────────────────────────────

package/mcp/dist/tools/memory.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";
@@ -7,7 +7,7 @@ import { recordFeedback, flushEntryScores, } from "../shared/governance.js";
 import { upsertCanonical } from "../shared/content.js";
 import { isValidProjectName } from "../utils.js";
 export function register(server, ctx) {
-    const { phrenPath, withWriteQueue, updateFileInIndex } = ctx;
+    const { withWriteQueue, updateFileInIndex } = ctx;
     server.registerTool("pin_memory", {
         title: "◆ phren · pin memory",
         description: "Write a truth — a high-confidence, always-inject entry in truths.md that never decays.",
@@ -15,19 +15,63 @@ export function register(server, ctx) {
             project: z.string().describe("Project name."),
             memory: z.string().describe("Truth text."),
         }),
-    }, async ({ project, memory }) => {
+    }, async ({ project: projectInput, memory }) => {
+        let phrenPath;
+        let project;
+        try {
+            const resolved = resolveStoreForProject(ctx, projectInput);
+            phrenPath = 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}"` });
         return withWriteQueue(async () => {
             const result = upsertCanonical(phrenPath, project, memory);
             if (!result.ok)
                 return mcpResponse({ ok: false, error: result.error });
-            // Update FTS index so newly added truth is immediately searchable
             const canonicalPath = path.join(phrenPath, project, "truths.md");
             updateFileInIndex(canonicalPath);
             return mcpResponse({ ok: true, message: result.data, data: { project, memory } });
         });
     });
+    server.registerTool("get_truths", {
+        title: "◆ phren · truths",
+        description: "Read all pinned truths for a project. Truths are high-confidence entries in truths.md that never decay.",
+        inputSchema: z.object({
+            project: z.string().describe("Project name."),
+        }),
+    }, async ({ project: projectInput }) => {
+        let phrenPath;
+        let project;
+        try {
+            const resolved = resolveStoreForProject(ctx, projectInput);
+            phrenPath = 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 truthsPath = path.join(phrenPath, project, "truths.md");
+        if (!fs.existsSync(truthsPath)) {
+            return mcpResponse({ ok: true, message: `No truths pinned for "${project}" yet.`, data: { project, truths: [], count: 0 } });
+        }
+        const content = fs.readFileSync(truthsPath, "utf8");
+        const truths = content.split("\n")
+            .filter((line) => line.startsWith("- "))
+            .map((line) => line.slice(2).trim());
+        return mcpResponse({
+            ok: true,
+            message: truths.length > 0
+                ? `${truths.length} truth(s) pinned for "${project}".`
+                : `No truths pinned for "${project}" yet.`,
+            data: { project, truths, count: truths.length },
+        });
+    });
     server.registerTool("memory_feedback", {
         title: "◆ phren · feedback",
         description: "Record feedback on whether an injected memory was helpful or noisy/regressive.",
@@ -36,6 +80,7 @@ export function register(server, ctx) {
             feedback: z.enum(["helpful", "reprompt", "regression"]).describe("Feedback type."),
         }),
     }, async ({ key, feedback }) => {
+        const phrenPath = ctx.phrenPath;
         return withWriteQueue(async () => {
             recordFeedback(phrenPath, key, feedback);
             flushEntryScores(phrenPath);

package/mcp/dist/tools/search.js

@@ -470,7 +470,7 @@ async function handleGetProjectSummary(ctx, { name }) {
         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"]]) {
+            for (const [file, type] of [["summary.md", "summary"], ["CLAUDE.md", "claude"], ["FINDINGS.md", "findings"], ["tasks.md", "task"], ["truths.md", "canonical"]]) {
                 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 });
@@ -487,6 +487,7 @@ async function handleGetProjectSummary(ctx, { name }) {
     }
     const summaryDoc = docs.find(doc => doc.type === "summary");
     const claudeDoc = docs.find(doc => doc.type === "claude");
+    const canonicalDoc = docs.find(doc => doc.type === "canonical");
     const indexedFiles = docs.map(doc => ({ filename: doc.filename, type: doc.type, path: doc.path }));
     const parts = [`# ${name}`];
     if (summaryDoc) {
@@ -498,6 +499,13 @@ async function handleGetProjectSummary(ctx, { name }) {
     if (claudeDoc) {
         parts.push(`\n## CLAUDE.md path\n\`${claudeDoc.path}\``);
     }
+    // Show truths if they exist
+    if (canonicalDoc) {
+        const truthLines = canonicalDoc.content.split("\n").filter((l) => l.startsWith("- "));
+        if (truthLines.length > 0) {
+            parts.push(`\n## Truths (${truthLines.length})\n${truthLines.join("\n")}`);
+        }
+    }
     const fileList = indexedFiles.map((f) => `- ${f.filename} (${f.type})`).join("\n");
     parts.push(`\n## Indexed files\n${fileList}`);
     return mcpResponse({
@@ -507,6 +515,7 @@ async function handleGetProjectSummary(ctx, { name }) {
             name,
             summary: summaryDoc?.content ?? null,
             claudeMdPath: claudeDoc?.path ?? null,
+            truthsPath: canonicalDoc?.path ?? null,
             files: indexedFiles,
         },
     });

package/mcp/dist/tools/session.js

@@ -18,6 +18,7 @@ import { listTaskCheckpoints, writeTaskCheckpoint } from "../session/checkpoints
 import { markImpactEntriesCompletedForSession } from "../finding/impact.js";
 import { atomicWriteJson, debugError, scanSessionFiles } from "../session/utils.js";
 import { getRuntimeHealth } from "../governance/policy.js";
+import { getProjectSourcePath, readProjectConfig } from "../project-config.js";
 const STALE_SESSION_MS = 24 * 60 * 60 * 1000; // 24 hours
 function collectGitStatusSnapshot(cwd) {
     try {
@@ -221,9 +222,11 @@ function cleanupStaleSessions(phrenPath) {
             // (no endedAt) should never be removed regardless of age.
             if (state && !state.endedAt)
                 continue;
-            // prefer startedAt from the JSON content over mtime (reliable on noatime mounts)
-            const ageMs = state?.startedAt
-                ? Date.now() - new Date(state.startedAt).getTime()
+            // For ended sessions, age out by end time rather than start time so
+            // long-running sessions do not disappear immediately after they finish.
+            const expirationAnchor = state?.endedAt || state?.startedAt;
+            const ageMs = expirationAnchor
+                ? Date.now() - new Date(expirationAnchor).getTime()
                 : Date.now() - fs.statSync(fullPath).mtimeMs;
             if (ageMs > STALE_SESSION_MS) {
                 fs.unlinkSync(fullPath);
@@ -607,7 +610,10 @@ export function register(server, ctx) {
                 })();
                 if (activeTask) {
                     const taskId = activeTask.stableId || activeTask.id;
-                    const { gitStatus, editedFiles } = collectGitStatusSnapshot(process.cwd());
+                    const projectConfig = readProjectConfig(phrenPath, endedState.project);
+                    const snapshotRoot = getProjectSourcePath(phrenPath, endedState.project, projectConfig) ||
+                        path.join(phrenPath, endedState.project);
+                    const { gitStatus, editedFiles } = collectGitStatusSnapshot(snapshotRoot);
                     const resumptionHint = extractResumptionHint(effectiveSummary, activeTask.line, activeTask.context || "No prior attempt captured");
                     writeTaskCheckpoint(phrenPath, {
                         project: endedState.project,

package/mcp/dist/tools/tasks.js

@@ -5,7 +5,7 @@ import * as path from "path";
 import { isValidProjectName } from "../utils.js";
 import { addTask as addTaskStore, addTasks as addTasksBatch, taskMarkdown, completeTask as completeTaskStore, completeTasks as completeTasksBatch, removeTask as removeTaskStore, removeTasks as removeTasksBatch, linkTaskIssue, pinTask, workNextTask, tidyDoneTasks, readTasks, readTasksAcrossProjects, resolveTaskItem, TASKS_FILENAME, updateTask as updateTaskStore, promoteTask, } from "../data/access.js";
 import { applyGravity } from "../data/tasks.js";
-import { parseGithubIssueUrl, } from "../task/github.js";
+import { buildTaskIssueBody, createGithubIssueForTask, parseGithubIssueUrl, resolveProjectGithubRepo, } from "../task/github.js";
 import { clearTaskCheckpoint } from "../session/checkpoints.js";
 import { incrementSessionTasksCompleted } from "./session.js";
 import { normalizeMemoryScope } from "../shared.js";
@@ -366,6 +366,7 @@ export function register(server, ctx) {
                 github_issue: z.union([z.number().int().positive(), z.string()]).optional().describe("GitHub issue number (for example 14 or '#14')."),
                 github_url: z.string().optional().describe("GitHub issue URL to associate with the task item."),
                 unlink_github: z.boolean().optional().describe("If true, remove any linked GitHub issue metadata from the item."),
+                create_issue: z.boolean().optional().describe("If true, create a GitHub issue for this task and link it."),
                 pin: z.boolean().optional().describe("If true, pin the task so it floats to the top of its section."),
                 promote: z.boolean().optional().describe("If true, clear the speculative flag on this task (confirm the user wants it)."),
                 move_to_active: z.boolean().optional().describe("Used with promote: also move the task to the Active section."),
@@ -382,6 +383,25 @@ export function register(server, ctx) {
         if (!updates.work_next && !item) {
             return mcpResponse({ ok: false, error: "item is required unless updates.work_next is true." });
         }
+        if (updates.create_issue) {
+            const extraUpdates = [
+                updates.text,
+                updates.priority,
+                updates.context,
+                updates.section,
+                updates.github_issue,
+                updates.github_url,
+                updates.unlink_github,
+                updates.pin,
+                updates.promote,
+                updates.move_to_active,
+                updates.work_next,
+                updates.replace_context,
+            ].some((value) => value !== undefined);
+            if (extraUpdates) {
+                return mcpResponse({ ok: false, error: "create_issue must be used by itself." });
+            }
+        }
         // Cross-validate github_issue and github_url
         if (updates.github_url) {
             const parsed = parseGithubIssueUrl(updates.github_url);
@@ -423,6 +443,45 @@ export function register(server, ctx) {
                     data: { project, item: result.data },
                 });
             }
+            if (updates.create_issue) {
+                const resolved = resolveTaskItem(phrenPath, project, item);
+                if (!resolved.ok)
+                    return mcpResponse({ ok: false, error: resolved.error });
+                const repo = resolveProjectGithubRepo(phrenPath, project);
+                if (!repo) {
+                    return mcpResponse({
+                        ok: false,
+                        error: "Could not infer a GitHub repo. Add a GitHub URL to CLAUDE.md or summary.md, or link an existing issue instead.",
+                    });
+                }
+                const created = createGithubIssueForTask({
+                    repo,
+                    title: resolved.data.line.replace(/\s*\[(high|medium|low)\]\s*$/i, "").trim(),
+                    body: buildTaskIssueBody(project, resolved.data),
+                });
+                if (!created.ok)
+                    return mcpResponse({ ok: false, error: created.error, errorCode: created.code });
+                const linked = linkTaskIssue(phrenPath, project, item, {
+                    github_issue: created.data.issueNumber,
+                    github_url: created.data.url,
+                });
+                if (!linked.ok)
+                    return mcpResponse({ ok: false, error: linked.error, errorCode: linked.code });
+                refreshTaskIndex(updateFileInIndex, phrenPath, project);
+                return mcpResponse({
+                    ok: true,
+                    message: `Created GitHub issue ${created.data.issueNumber ? `#${created.data.issueNumber}` : created.data.url} for ${project} task.`,
+                    data: {
+                        project,
+                        item,
+                        issue_number: created.data.issueNumber ?? null,
+                        issue_url: created.data.url,
+                        githubIssue: linked.data.githubIssue ?? null,
+                        githubUrl: linked.data.githubUrl || null,
+                        stableId: linked.data.stableId || null,
+                    },
+                });
+            }
             // Handle github issue linking via update_task when github_issue or github_url is set (and no other field updates)
             if ((updates.github_issue !== undefined || updates.github_url || updates.unlink_github) && !updates.text && !updates.priority && !updates.context && !updates.section) {
                 if (updates.unlink_github && (updates.github_issue !== undefined || updates.github_url)) {

package/mcp/dist/tools/types.js

@@ -8,6 +8,16 @@ import { resolveAllStores } from "../store-registry.js";
 export function resolveStoreForProject(ctx, projectInput) {
     const { storeName, projectName } = parseStoreQualified(projectInput);
     if (!storeName) {
+        // Check if any non-readonly store claims this project via projects[] array.
+        // This enables automatic write routing: once a project is claimed by a team
+        // store (via `phren team add-project`), writes go there without needing the
+        // store-qualified prefix.
+        const stores = resolveAllStores(ctx.phrenPath);
+        for (const store of stores) {
+            if (store.role !== "readonly" && store.role !== "primary" && store.projects?.includes(projectName)) {
+                return { phrenPath: store.path, project: projectName, storeRole: store.role };
+            }
+        }
         return { phrenPath: ctx.phrenPath, project: projectName, storeRole: "primary" };
     }
     const stores = resolveAllStores(ctx.phrenPath);

package/package.json

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

package/skills/sync/SKILL.md

@@ -102,7 +102,7 @@ If this fails (not a git repo, no remote), tell the user. Don't silently skip.
 Run init against the pulled phren repo so hooks, MCP registration, and machine/profile wiring are refreshed:
 
 ```bash
-PHREN_PATH="$PHREN_DIR" npx phren init -y
+PHREN_PATH="$PHREN_DIR" phren init -y
 ```
 
 If the user is in an untracked repo afterward, tell them to open a session there and let the agent ask, or run `phren add` from that directory.

package/starter/README.md

@@ -32,7 +32,7 @@ New to phren? Here's what each file does and when it matters.
 
 **FINDINGS.md** fills itself. As Claude discovers insights, patterns, and decisions during your sessions, it tells phren and entries land here grouped by date. Old entries fade from retrieval over time. Wrong entries can be removed with `remove_finding()`.
 
-**tasks.md** is your task board file. It keeps Active (working now), Queue (up next), and Done (finished) in one place so the work history stays with the project. You can also manage it from `npx phren shell`.
+**tasks.md** is your task board file. It keeps Active (working now), Queue (up next), and Done (finished) in one place so the work history stays with the project. You can also manage it from `phren shell`.
 
 **global/CLAUDE.md** applies everywhere. Your style preferences, tool choices, things Claude should always know regardless of which project you're in.
 
@@ -40,14 +40,14 @@ New to phren? Here's what each file does and when it matters.
 
 ## Getting started
 
-If you got here via `npx phren init`, you're already set up. Restart Claude Code and you're good.
+If you got here via `npx @phren/cli init`, you're already set up. Restart Claude Code and you're good.
 
 If you cloned manually:
 
-1. Add the MCP server: `claude mcp add phren -- npx phren ~/.phren`
+1. Add the MCP server: `claude mcp add phren -- npx @phren/cli ~/.phren`
 2. Install skills: `/plugin marketplace add alaarab/phren` then `/plugin install phren@phren`
 3. Restart Claude Code
-4. Add a project: run `/phren-init my-project` or scaffold one with a template such as `npx phren init --template python-project`
+4. Add a project: run `/phren-init my-project` or scaffold one with a template such as `phren init --template python-project`
 5. Push to a private GitHub repo to sync across machines
 
 ## Day-to-day workflow
@@ -56,7 +56,7 @@ If you cloned manually:
 2. **Work normally**: Claude reads your project docs and builds on what phren remembers
 3. **Fragments accumulate**: tell phren what you learned, or he picks up insights automatically
 4. **Session ends**: phren commits and pushes what he collected
-5. **Review occasionally**: run `npx phren shell` to triage what phren queued, manage tasks, and check health
+5. **Review occasionally**: run `phren shell` to triage what phren queued, manage tasks, and check health
 
 ## Syncing across machines
 
@@ -71,4 +71,4 @@ Each profile in `profiles/` lists which projects that machine should see. After
 
 ## Troubleshooting
 
-Run `npx phren doctor --fix` to check and repair your setup.
+Run `phren doctor --fix` to check and repair your setup.

package/starter/machines.yaml

@@ -5,4 +5,4 @@
 #   work-laptop: work
 #   home-desktop: personal
 #
-# After adding a line, run: npx phren init
+# After adding a line, run: phren init

package/starter/my-first-project/tasks.md

@@ -22,4 +22,4 @@
 
 ## Done
 
-- [x] Run `npx phren init` to set up phren
+- [x] Run `phren init` to set up phren

package/starter/templates/README.md

@@ -1,6 +1,6 @@
 # starter/templates/
 
-Project templates bundled in the npm package, used by `npx phren init --template <name>`.
+Project templates bundled in the npm package, used by `phren init --template <name>`.
 
 Each subdirectory (frontend, library, monorepo, python-project) contains pre-filled project files with sensible defaults for that project type. When a user runs init with `--template`, these files are copied into their `~/.phren/<project>/` directory. For other project types, adaptive init infers topics and structure from repo content.