@phren/cli 0.0.36 → 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/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/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/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/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/package.json

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