@phren/cli 0.0.35 → 0.0.37

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

@@ -434,6 +434,34 @@ export async function handleHookStop() {
             }
             return;
         }
+        // Check if HEAD has an upstream tracking branch before attempting sync.
+        // Detached HEAD or branches without upstream would cause silent push failures.
+        const upstream = await runBestEffortGit(["rev-parse", "--abbrev-ref", "@{upstream}"], phrenPath);
+        if (!upstream.ok || !upstream.output) {
+            const unsyncedCommits = await countUnsyncedCommits(phrenPath);
+            const noUpstreamDetail = "commit created; no upstream tracking branch";
+            finalizeTaskSession({
+                phrenPath,
+                sessionId: taskSessionId,
+                status: "no-upstream",
+                detail: noUpstreamDetail,
+            });
+            updateRuntimeHealth(phrenPath, {
+                lastStopAt: now,
+                lastAutoSave: { at: now, status: "no-upstream", detail: noUpstreamDetail },
+                lastSync: {
+                    lastPushAt: now,
+                    lastPushStatus: "no-upstream",
+                    lastPushDetail: noUpstreamDetail,
+                    unsyncedCommits,
+                },
+            });
+            appendAuditLog(phrenPath, "hook_stop", "status=no-upstream");
+            if (unsyncedCommits > 3) {
+                process.stderr.write(`phren: ${unsyncedCommits} unsynced commits — no upstream tracking branch.\n`);
+            }
+            return;
+        }
         const unsyncedCommits = await countUnsyncedCommits(phrenPath);
         const scheduled = scheduleBackgroundSync(phrenPath);
         const syncDetail = scheduled

package/mcp/dist/content/learning.js

@@ -305,7 +305,7 @@ export function addFindingToFile(phrenPath, project, learning, citationInput, op
                 return phrenOk(`Skipped duplicate finding for "${project}": already exists with similar wording.`);
             }
             const newContent = `# ${project} Findings\n\n## ${today}\n\n${preparedForNewFile.finding.bullet}\n${preparedForNewFile.finding.citationComment}\n`;
-            const tmpPath = learningsPath + ".tmp." + process.pid;
+            const tmpPath = learningsPath + `.tmp-${crypto.randomUUID()}`;
             fs.writeFileSync(tmpPath, newContent);
             fs.renameSync(tmpPath, learningsPath);
             return phrenOk({
@@ -461,7 +461,7 @@ export function addFindingsToFile(phrenPath, project, learnings, opts) {
                 added.push(learning);
             }
             if (added.length > 0) {
-                const tmpPath = learningsPath + ".tmp." + process.pid;
+                const tmpPath = learningsPath + `.tmp-${crypto.randomUUID()}`;
                 fs.writeFileSync(tmpPath, content.endsWith("\n") ? content : `${content}\n`);
                 fs.renameSync(tmpPath, learningsPath);
             }

package/mcp/dist/data/access.js

@@ -113,6 +113,7 @@ export function readFindings(phrenPath, project, opts = {}) {
     let date = "unknown";
     let index = 1;
     let inArchiveBlock = false;
+    let headingTag;
     const includeArchived = opts.includeArchived ?? false;
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
@@ -134,6 +135,39 @@ export function readFindings(phrenPath, project, opts = {}) {
             date = extractedDate;
             continue;
         }
+        // Support heading-based findings: ## topic / ### title / paragraph
+        const h2TagMatch = line.match(/^##\s+([a-z_-]+)\s*$/i);
+        if (h2TagMatch && !line.match(/^##\s+\d{4}/)) {
+            // Track topic heading (but not date headings like ## 2026-03-22)
+            headingTag = h2TagMatch[1].toLowerCase();
+            continue;
+        }
+        const h3Match = line.match(/^###\s+(.+)$/);
+        if (h3Match && headingTag) {
+            let body = "";
+            for (let j = i + 1; j < lines.length; j++) {
+                const next = lines[j].trim();
+                if (!next)
+                    continue;
+                if (next.startsWith("#") || next.startsWith("- "))
+                    break;
+                body = next;
+                break;
+            }
+            const title = h3Match[1].trim();
+            const syntheticText = body ? `[${headingTag}] ${title} — ${body}` : `[${headingTag}] ${title}`;
+            items.push({
+                id: `L${index}`,
+                date,
+                text: syntheticText,
+                source: "unknown",
+                status: "active",
+                archived: inArchiveBlock,
+                tier: inArchiveBlock ? "archived" : "current",
+            });
+            index++;
+            continue;
+        }
         if (!line.startsWith("- "))
             continue;
         const next = lines[i + 1] || "";

package/mcp/dist/governance/locks.js

@@ -24,40 +24,11 @@ function acquireFileLock(lockPath) {
             try {
                 const stat = fs.statSync(lockPath);
                 if (Date.now() - stat.mtimeMs > staleThreshold) {
-                    // Verify lock owner PID is dead before removing stale lock
-                    let ownerDead = true;
-                    try {
-                        const lockContent = fs.readFileSync(lockPath, "utf8");
-                        const lockPid = Number.parseInt(lockContent.split("\n")[0], 10);
-                        if (Number.isFinite(lockPid) && lockPid > 0) {
-                            if (process.platform !== 'win32') {
-                                try {
-                                    process.kill(lockPid, 0);
-                                    ownerDead = false;
-                                }
-                                catch {
-                                    ownerDead = true;
-                                }
-                            }
-                            else {
-                                try {
-                                    const result = require('child_process').spawnSync('tasklist', ['/FI', `PID eq ${lockPid}`, '/NH'], { encoding: 'utf8', timeout: 2000 });
-                                    if (result.stdout && result.stdout.includes(String(lockPid)))
-                                        ownerDead = false;
-                                }
-                                catch {
-                                    ownerDead = true;
-                                }
-                            }
-                        }
-                    }
-                    catch {
-                        ownerDead = true; // Can't read lock file, treat as dead
-                    }
-                    if (ownerDead) {
-                        fs.unlinkSync(lockPath);
-                        continue;
-                    }
+                    // Lock file is older than stale threshold — delete unconditionally.
+                    // This handles zombie processes, crashed hooks, and any case where
+                    // the owning process failed to clean up.
+                    fs.unlinkSync(lockPath);
+                    continue;
                 }
             }
             catch (statErr) {

package/mcp/dist/governance/policy.js

@@ -143,7 +143,7 @@ function normalizeRuntimeHealth(data) {
         normalized.lastPromptAt = data.lastPromptAt;
     if (typeof data.lastStopAt === "string")
         normalized.lastStopAt = data.lastStopAt;
-    if (isRecord(data.lastAutoSave) && typeof data.lastAutoSave.at === "string" && ["clean", "saved-local", "saved-pushed", "error"].includes(String(data.lastAutoSave.status))) {
+    if (isRecord(data.lastAutoSave) && typeof data.lastAutoSave.at === "string" && ["clean", "saved-local", "saved-pushed", "no-upstream", "error"].includes(String(data.lastAutoSave.status))) {
         normalized.lastAutoSave = {
             at: data.lastAutoSave.at,
             status: data.lastAutoSave.status,
@@ -169,7 +169,7 @@ function normalizeRuntimeHealth(data) {
             normalized.lastSync.lastSuccessfulPullAt = data.lastSync.lastSuccessfulPullAt;
         if (typeof data.lastSync.lastPushAt === "string")
             normalized.lastSync.lastPushAt = data.lastSync.lastPushAt;
-        if (["saved-local", "saved-pushed", "error"].includes(String(data.lastSync.lastPushStatus)))
+        if (["saved-local", "saved-pushed", "no-upstream", "error"].includes(String(data.lastSync.lastPushStatus)))
             normalized.lastSync.lastPushStatus = data.lastSync.lastPushStatus;
         if (typeof data.lastSync.lastPushDetail === "string")
             normalized.lastSync.lastPushDetail = data.lastSync.lastPushDetail;

package/mcp/dist/init/init.js

@@ -118,7 +118,7 @@ export function parseMcpMode(raw) {
 function normalizedBootstrapProjectName(projectPath) {
     return path.basename(projectPath).toLowerCase().replace(/[^a-z0-9_-]/g, "-");
 }
-function getPendingBootstrapTarget(phrenPath, opts) {
+function getPendingBootstrapTarget(phrenPath, _opts) {
     const cwdProject = detectProjectDir(process.cwd(), phrenPath);
     if (!cwdProject)
         return null;

package/mcp/dist/init/setup.js

@@ -884,15 +884,25 @@ export function ensureProjectScaffold(projectDir, projectName, domain = "softwar
     }
 }
 export function ensureLocalGitRepo(phrenPath) {
+    // Check if phrenPath already has its own git repo (not just being inside a parent)
     try {
-        execFileSync("git", ["-C", phrenPath, "rev-parse", "--is-inside-work-tree"], {
-            stdio: ["ignore", "ignore", "ignore"],
+        const topLevel = execFileSync("git", ["-C", phrenPath, "rev-parse", "--show-toplevel"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
             timeout: EXEC_TIMEOUT_QUICK_MS,
-        });
-        return { ok: true, initialized: false, detail: "existing git repo" };
+        }).trim();
+        const resolvedTopLevel = path.resolve(topLevel);
+        const resolvedPhrenPath = path.resolve(phrenPath);
+        if (resolvedTopLevel === resolvedPhrenPath) {
+            // phrenPath IS the repo root — it has its own git repo
+            return { ok: true, initialized: false, detail: "existing git repo" };
+        }
+        // phrenPath is inside a parent repo — skip nested init
+        logger.warn("init", `Skipping git init: ${resolvedPhrenPath} is inside existing repo ${resolvedTopLevel}`);
+        return { ok: true, initialized: false, detail: `skipped: inside existing repo ${resolvedTopLevel}` };
     }
     catch {
-        // Fall through to initialization below.
+        // Not inside any git repo — fall through to initialization below.
     }
     try {
         try {

package/mcp/dist/init-uninstall.js

@@ -170,8 +170,17 @@ function filterAgentHooks(filePath, commandField) {
         return true;
     }
     catch (err) {
-        debugLog(`filterAgentHooks: failed for ${filePath}: ${errorMessage(err)}`);
-        return false;
+        // JSON parse or other failure — back up the corrupted file so uninstall can proceed
+        const bakPath = filePath + ".bak";
+        try {
+            fs.renameSync(filePath, bakPath);
+            log(`  Warning: corrupted hook config backed up to ${bakPath} (${errorMessage(err)})`);
+        }
+        catch (bakErr) {
+            debugLog(`filterAgentHooks: backup failed for ${filePath}: ${errorMessage(bakErr)}`);
+            log(`  Warning: could not process hook config ${filePath}: ${errorMessage(err)}`);
+        }
+        return true;
     }
 }
 async function promptUninstallConfirm(phrenPath) {

package/mcp/dist/phren-paths.js

@@ -35,7 +35,16 @@ export function atomicWriteText(filePath, content) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     const tmpPath = `${filePath}.tmp-${crypto.randomUUID()}`;
     fs.writeFileSync(tmpPath, content);
-    fs.renameSync(tmpPath, filePath);
+    try {
+        fs.renameSync(tmpPath, filePath);
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(tmpPath);
+        }
+        catch { }
+        throw err;
+    }
 }
 function isInstallMode(value) {
     return value === "shared" || value === "project-local";

package/mcp/dist/shared/fragment-graph.js

@@ -232,7 +232,7 @@ function parseUserDefinedFragments(phrenPath, project) {
     }
 }
 /** Clear the user fragment cache (call between index builds). */
-function clearUserFragmentCache() {
+function _clearUserFragmentCache() {
     _userFragmentCache.clear();
     _buildUserFragmentCache.clear();
     _activeBuildCacheKeyPrefix = null;

package/mcp/dist/shared/index.js

@@ -22,7 +22,13 @@ export { buildSourceDocKey, decodeFiniteNumber, decodeStringRow, extractSnippet,
 // ── Async embedding queue ───────────────────────────────────────────────────
 const _embQueue = new Map();
 let _embTimer = null;
+const MAX_EMB_QUEUE = 500;
 function scheduleEmbedding(phrenPath, docPath, content) {
+    if (_embQueue.size >= MAX_EMB_QUEUE) {
+        const oldest = _embQueue.keys().next().value;
+        if (oldest !== undefined)
+            _embQueue.delete(oldest);
+    }
     _embQueue.set(docPath, { phrenPath, content });
     if (_embTimer)
         clearTimeout(_embTimer);
@@ -63,6 +69,7 @@ async function _drainEmbQueue() {
             }
             catch (err) {
                 logger.debug("embeddingQueue embedText", errorMessage(err));
+                _embQueue.clear();
             }
         }
         try {
@@ -70,6 +77,7 @@ async function _drainEmbQueue() {
         }
         catch (err) {
             logger.debug("embeddingQueue cacheFlush", errorMessage(err));
+            _embQueue.clear();
         }
     }
 }

package/mcp/dist/shell/entry.js

@@ -63,7 +63,7 @@ async function playStartupIntro(phrenPath, plan = resolveStartupIntroPlan(phrenP
     // Start animated phren during loading
     const animator = createPhrenAnimator({ facing: "right" });
     animator.start();
-    const cols = process.stdout.columns || 80;
+    const _cols = process.stdout.columns || 80;
     const tagline = style.dim("local memory for working agents");
     const versionBadge = badge(`v${VERSION}`, style.boldBlue);
     const logoLines = [

package/mcp/dist/task/lifecycle.js

@@ -302,7 +302,7 @@ export function finalizeTaskSession(args) {
     if (!state || state.mode !== "auto")
         return;
     const match = state.stableId ? `bid:${state.stableId}` : state.item;
-    if (args.status === "saved-local" || args.status === "saved-pushed") {
+    if (args.status === "saved-local" || args.status === "saved-pushed" || args.status === "no-upstream") {
         const completed = completeTask(args.phrenPath, state.project, match);
         if (!completed.ok) {
             debugLog(`task lifecycle complete ${state.project}: ${completed.error}`);

package/mcp/dist/tools/search.js

@@ -456,7 +456,6 @@ async function handleSearchKnowledge(ctx, { query, limit, project, type, tag, si
     }
 }
 async function handleGetProjectSummary(ctx, { name }) {
-    const { phrenPath } = ctx;
     const db = ctx.db();
     const docs = queryDocRows(db, "SELECT project, filename, type, content, path FROM docs WHERE project = ?", [name]);
     if (!docs) {

package/mcp/dist/ui/data.js

@@ -194,8 +194,62 @@ export async function buildGraph(phrenPath, profile, focusProject, existingDb) {
         const MAX_UNTAGGED = isFocused ? Infinity : 100;
         let taggedCount = 0;
         let untaggedAdded = 0;
-        for (const line of lines) {
-            // Support legacy tagged findings like [decision], [pitfall], etc.
+        // Support heading-based findings: ## topic / ### title / paragraph
+        let currentHeadingTag;
+        let _currentHeadingTitle;
+        for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+            const line = lines[lineIdx];
+            // Track heading context for heading-based findings
+            const h2Match = line.match(/^##\s+([a-z_-]+)\s*$/i);
+            if (h2Match) {
+                currentHeadingTag = h2Match[1].toLowerCase();
+                _currentHeadingTitle = undefined;
+                continue;
+            }
+            const h3Match = line.match(/^###\s+(.+)$/);
+            if (h3Match && currentHeadingTag) {
+                // Read the next non-empty line as the body
+                let body = "";
+                for (let j = lineIdx + 1; j < lines.length; j++) {
+                    const next = lines[j].trim();
+                    if (!next)
+                        continue;
+                    if (next.startsWith("#"))
+                        break;
+                    body = next;
+                    break;
+                }
+                const title = h3Match[1].trim();
+                const text = body ? `${title} — ${body}` : title;
+                if (text.length >= 10) {
+                    if (taggedCount >= MAX_TAGGED)
+                        continue;
+                    const topic = classifyTopicForText(`[${currentHeadingTag}] ${text}`, projectTopics);
+                    const scoreKey = entryScoreKey(project, "FINDINGS.md", `[${currentHeadingTag}] ${text}`);
+                    const nodeId = stableId("finding", scoreKey);
+                    taggedCount++;
+                    nodes.push({
+                        id: nodeId,
+                        label: text.length > 55 ? `${text.slice(0, 52)}...` : text,
+                        fullLabel: text,
+                        group: `topic:${topic.slug}`,
+                        refCount: taggedCount,
+                        project,
+                        tagged: true,
+                        scoreKey,
+                        scoreKeys: [scoreKey],
+                        refDocs: [{ doc: `${project}/FINDINGS.md`, project, scoreKey }],
+                        topicSlug: topic.slug,
+                        topicLabel: topic.label,
+                    });
+                    links.push({ source: project, target: nodeId });
+                    for (const other of exactProjectMentions(text, projectSet, project)) {
+                        links.push({ source: project, target: other });
+                    }
+                }
+                continue;
+            }
+            // Standard bullet-based findings: - [tag] text
             const tagMatch = line.match(/^-\s+\[([a-z_-]+)\]\s+(.+?)(?:\s*<!--.*-->)?$/);
             if (tagMatch) {
                 if (taggedCount >= MAX_TAGGED)

package/package.json

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