@phren/cli 0.0.41 → 0.0.43

package/mcp/dist/init-fresh.js

@@ -197,8 +197,8 @@ export async function runFreshInstall(phrenPath, opts, params) {
     log(`\nNext steps:`);
     let step = 1;
     log(`  ${step++}. Start a new Claude session in your project directory — phren injects context automatically`);
-    log(`  ${step++}. Run \`npx phren doctor\` to verify everything is wired correctly`);
-    log(`  ${step++}. Change defaults anytime: \`npx phren config project-ownership\`, \`npx phren config workflow\`, \`npx phren config proactivity.findings\`, \`npx phren config proactivity.tasks\``);
+    log(`  ${step++}. Run \`phren doctor\` to verify everything is wired correctly`);
+    log(`  ${step++}. Change defaults anytime: \`phren config project-ownership\`, \`phren config workflow\`, \`phren config proactivity.findings\`, \`phren config proactivity.tasks\``);
     const gh = opts._walkthroughGithub;
     if (gh) {
         const remote = gh.username
@@ -223,9 +223,9 @@ export async function runFreshInstall(phrenPath, opts, params) {
         log(`     git remote add origin git@github.com:YOUR_USERNAME/my-phren.git`);
         log(`     git push -u origin main`);
     }
-    log(`  ${step++}. Add more projects: cd ~/your-project && npx phren add`);
+    log(`  ${step++}. Add more projects: cd ~/your-project && phren add`);
     if (!mcpEnabled) {
-        log(`  ${step++}. Turn MCP on: npx phren mcp-mode on`);
+        log(`  ${step++}. Turn MCP on: phren mcp-mode on`);
     }
     log(`  ${step++}. After your first week, run phren-discover to surface gaps in your project knowledge`);
     log(`  ${step++}. After working across projects, run phren-consolidate to find cross-project patterns`);

package/mcp/dist/init-hooks.js

@@ -21,6 +21,6 @@ export function configureHooksIfEnabled(phrenPath, hooksEnabled, verb) {
         }
     }
     else {
-        log(`  Hooks are disabled by preference (run: npx phren hooks-mode on)`);
+        log(`  Hooks are disabled by preference (run: phren hooks-mode on)`);
     }
 }

package/mcp/dist/init-modes.js

@@ -24,8 +24,8 @@ export async function runMcpMode(modeArg) {
         const hooks = getHooksEnabledPreference(phrenPath);
         log(`MCP mode: ${current ? "on (recommended)" : "off (hooks-only fallback)"}`);
         log(`Hooks mode: ${hooks ? "on (active)" : "off (disabled)"}`);
-        log(`Change mode: npx phren mcp-mode on|off`);
-        log(`Hooks toggle: npx phren hooks-mode on|off`);
+        log(`Change mode: phren mcp-mode on|off`);
+        log(`Hooks toggle: phren hooks-mode on|off`);
         return;
     }
     const mode = parseMcpMode(normalizedArg);
@@ -93,7 +93,7 @@ export async function runHooksMode(modeArg) {
     if (!normalizedArg || normalizedArg === "status") {
         const current = getHooksEnabledPreference(phrenPath);
         log(`Hooks mode: ${current ? "on (active)" : "off (disabled)"}`);
-        log(`Change mode: npx phren hooks-mode on|off`);
+        log(`Change mode: phren hooks-mode on|off`);
         return;
     }
     const mode = parseMcpMode(normalizedArg);

package/mcp/dist/init-update.js

@@ -53,7 +53,7 @@ export async function runExistingInstallUpdate(phrenPath, opts, params) {
     const previousVersion = prefs.installedVersion;
     if (isVersionNewer(VERSION, previousVersion)) {
         log(`\n  Starter template update available: v${previousVersion} -> v${VERSION}`);
-        log(`  Run \`npx phren init --apply-starter-update\` to refresh global/CLAUDE.md and global skills.`);
+        log(`  Run \`phren init --apply-starter-update\` to refresh global/CLAUDE.md and global skills.`);
     }
     if (opts.applyStarterUpdate) {
         const updated = applyStarterTemplateUpdates(phrenPath);
@@ -88,8 +88,8 @@ export async function runExistingInstallUpdate(phrenPath, opts, params) {
     log(`\n\x1b[95m◆\x1b[0m phren updated successfully`);
     log(`\nNext steps:`);
     log(`  1. Start a new Claude session in your project directory — phren injects context automatically`);
-    log(`  2. Run \`npx phren doctor\` to verify everything is wired correctly`);
-    log(`  3. Change defaults anytime: \`npx phren config project-ownership\`, \`npx phren config workflow\`, \`npx phren config proactivity.findings\`, \`npx phren config proactivity.tasks\``);
+    log(`  2. Run \`phren doctor\` to verify everything is wired correctly`);
+    log(`  3. Change defaults anytime: \`phren config project-ownership\`, \`phren config workflow\`, \`phren config proactivity.findings\`, \`phren config proactivity.tasks\``);
     log(`  4. After your first week, run phren-discover to surface gaps in your project knowledge`);
     log(`  5. After working across projects, run phren-consolidate to find cross-project patterns`);
     log(``);

package/mcp/dist/init-walkthrough.js

@@ -269,7 +269,7 @@ export async function runWalkthrough(phrenPath) {
     log("  phren-managed: Phren may mirror CLAUDE.md / AGENTS.md into the repo");
     log("  detached: Phren keeps its own docs but does not write into the repo");
     log("  repo-managed: keep the repo's existing CLAUDE/AGENTS files as canonical");
-    log("  Change later: npx phren config project-ownership <mode>");
+    log("  Change later: phren config project-ownership <mode>");
     const projectOwnershipDefault = await prompts.select("Default project ownership", [
         { value: "detached", name: "detached (default)" },
         { value: "phren-managed", name: "phren-managed" },
@@ -280,7 +280,7 @@ export async function runWalkthrough(phrenPath) {
     log("directly: search memory, manage tasks, save findings, etc.");
     log("  Recommended for: Claude Code, Cursor, Copilot CLI, Codex");
     log("  Alternative: hooks-only mode (read-only context injection, any agent)");
-    log("  Change later: npx phren mcp-mode on|off");
+    log("  Change later: phren mcp-mode on|off");
     const mcp = (await prompts.confirm("Enable MCP?", true)) ? "on" : "off";
     printSection("Hooks");
     log("Hooks run shell commands at session start, prompt submit, and session end.");
@@ -288,7 +288,7 @@ export async function runWalkthrough(phrenPath) {
     log("  - UserPromptSubmit: searches phren and injects relevant context");
     log("  - Stop: commits and pushes any new findings after each response");
     log("  What they touch: ~/.claude/settings.json (hooks section only)");
-    log("  Change later: npx phren hooks-mode on|off");
+    log("  Change later: phren hooks-mode on|off");
     const hooks = (await prompts.confirm("Enable hooks?", true)) ? "on" : "off";
     printSection("Semantic Search (Optional)");
     log("Phren can use a local embedding model for semantic (fuzzy) search via Ollama.");
@@ -336,7 +336,7 @@ export async function runWalkthrough(phrenPath) {
     let findingsProactivity = "high";
     if (autoCaptureEnabled) {
         log("  Findings capture level controls how eager phren is to save lessons automatically.");
-        log("  Change later: npx phren config proactivity.findings <high|medium|low>");
+        log("  Change later: phren config proactivity.findings <high|medium|low>");
         findingsProactivity = await prompts.select("Findings capture level", [
             { value: "high", name: "high (recommended)" },
             { value: "medium", name: "medium" },
@@ -352,7 +352,7 @@ export async function runWalkthrough(phrenPath) {
     log("  suggest: proposes tasks but waits for approval before writing");
     log("  manual: tasks are fully manual — you add them yourself");
     log("  off: never touch tasks automatically");
-    log("  Change later: npx phren config workflow set --taskMode=<mode>");
+    log("  Change later: phren config workflow set --taskMode=<mode>");
     const taskMode = await prompts.select("Task mode", [
         { value: "auto", name: "auto (recommended)" },
         { value: "suggest", name: "suggest" },
@@ -365,7 +365,7 @@ export async function runWalkthrough(phrenPath) {
         log("  high (recommended): captures tasks as they come up naturally");
         log("  medium: only when you explicitly mention a task");
         log("  low: minimal auto-capture");
-        log("  Change later: npx phren config proactivity.tasks <high|medium|low>");
+        log("  Change later: phren config proactivity.tasks <high|medium|low>");
         taskProactivity = await prompts.select("Task proactivity", [
             { value: "high", name: "high (recommended)" },
             { value: "medium", name: "medium" },
@@ -376,7 +376,7 @@ export async function runWalkthrough(phrenPath) {
     log("Choose how strict review gates should be for risky or low-confidence writes.");
     log("  lowConfidenceThreshold: confidence cutoff used to mark writes as risky");
     log("  riskySections: sections always treated as risky");
-    log("  Change later: npx phren config workflow set --lowConfidenceThreshold=0.7 --riskySections=Stale,Conflicts");
+    log("  Change later: phren config workflow set --lowConfidenceThreshold=0.7 --riskySections=Stale,Conflicts");
     const thresholdAnswer = await prompts.input("Low-confidence threshold [0.0-1.0]", "0.7");
     const lowConfidenceThreshold = parseLowConfidenceThreshold(thresholdAnswer, 0.7);
     const riskySectionsAnswer = await prompts.input("Risky sections [Review,Stale,Conflicts]", "Stale,Conflicts");
@@ -426,7 +426,7 @@ export async function runWalkthrough(phrenPath) {
     log("  conservative — decisions and pitfalls only");
     log("  balanced     — non-obvious patterns, decisions, pitfalls, bugs (recommended)");
     log("  aggressive   — everything worth remembering, err on the side of capturing");
-    log("  Change later: npx phren config finding-sensitivity <level>");
+    log("  Change later: phren config finding-sensitivity <level>");
     const findingSensitivity = await prompts.select("Finding sensitivity", [
         { value: "balanced", name: "balanced (recommended)" },
         { value: "conservative", name: "conservative" },
@@ -455,7 +455,7 @@ export async function runWalkthrough(phrenPath) {
         bootstrapCurrentProject = await prompts.confirm("Add this project to phren now?", true);
         if (!bootstrapCurrentProject) {
             bootstrapCurrentProject = false;
-            log(style.warning(`  Skipped. Later: cd ${detectedProject} && npx phren add`));
+            log(style.warning(`  Skipped. Later: cd ${detectedProject} && phren add`));
         }
         else {
             bootstrapOwnership = await prompts.select("Ownership for detected project", [

package/mcp/dist/link/link.js

@@ -76,7 +76,7 @@ function maybeOfferStarterTemplateUpdate(phrenPath) {
         const prefs = JSON.parse(fs.readFileSync(prefsPath, "utf8"));
         if (isVersionNewer(current, prefs.installedVersion)) {
             log(`  Starter template update available: v${prefs.installedVersion} -> v${current}`);
-            log(`  Run \`npx phren init --apply-starter-update\` to refresh global/CLAUDE.md and global skills.`);
+            log(`  Run \`phren init --apply-starter-update\` to refresh global/CLAUDE.md and global skills.`);
         }
     }
     catch (err) {

package/mcp/dist/phren-paths.js

@@ -209,7 +209,7 @@ export function findPhrenPathWithArg(arg) {
     const existing = findPhrenPath();
     if (existing)
         return existing;
-    throw new Error(`${PhrenError.NOT_FOUND}: phren root not found. Run 'npx phren init'.`);
+    throw new Error(`${PhrenError.NOT_FOUND}: phren root not found. Run 'phren init'.`);
 }
 export function isProjectLocalMode(phrenPath) {
     try {
@@ -513,7 +513,7 @@ export function getPhrenPath() {
     if (!lazyPhrenPath) {
         const existing = findPhrenPath();
         if (!existing)
-            throw new Error(`${PhrenError.NOT_FOUND}: phren root not found. Run 'npx phren init'.`);
+            throw new Error(`${PhrenError.NOT_FOUND}: phren root not found. Run 'phren init'.`);
         lazyPhrenPath = existing;
     }
     return lazyPhrenPath;

package/mcp/dist/profile-store.js

@@ -45,7 +45,7 @@ export function resolveActiveProfile(phrenPath, requestedProfile) {
 export function listMachines(phrenPath) {
     const machinesPath = path.join(phrenPath, "machines.yaml");
     if (!fs.existsSync(machinesPath))
-        return phrenErr(`machines.yaml not found. Run 'npx phren init' to set up your phren.`, PhrenError.FILE_NOT_FOUND);
+        return phrenErr(`machines.yaml not found. Run 'phren init' to set up your phren.`, PhrenError.FILE_NOT_FOUND);
     try {
         const raw = fs.readFileSync(machinesPath, "utf8");
         const parsed = yaml.load(raw, { schema: yaml.CORE_SCHEMA });
@@ -205,7 +205,7 @@ export function getActiveProfileDefaults(phrenPath, profile) {
 export function listProfiles(phrenPath) {
     const profilesDir = path.join(phrenPath, "profiles");
     if (!fs.existsSync(profilesDir))
-        return phrenErr(`No profiles/ directory found. Run 'npx phren init' to set up your phren.`, PhrenError.FILE_NOT_FOUND);
+        return phrenErr(`No profiles/ directory found. Run 'phren init' to set up your phren.`, PhrenError.FILE_NOT_FOUND);
     const files = fs.readdirSync(profilesDir).filter((file) => file.endsWith(".yaml")).sort();
     const profiles = [];
     for (const file of files) {

package/mcp/dist/status.js

@@ -53,7 +53,7 @@ function hasCommandHook(value) {
 export async function runStatus() {
     const phrenPath = findPhrenPath();
     if (!phrenPath) {
-        console.log(`${RED}phren not found${RESET}. Run ${CYAN}npx phren init${RESET} to set up.`);
+        console.log(`${RED}phren not found${RESET}. Run ${CYAN}npx @phren/cli init${RESET} to set up.`);
         process.exit(1);
     }
     const cwd = process.cwd();

package/mcp/dist/tools/finding.js

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

package/mcp/dist/tools/search.js

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

package/mcp/dist/tools/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

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

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

package/package.json

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