@phren/cli 0.0.28 → 0.0.32

package/mcp/dist/{mcp-ops.js → tools/ops.js}

@@ -1,16 +1,19 @@
-import { mcpResponse } from "./mcp-types.js";
+import { mcpResponse } from "./types.js";
 import { z } from "zod";
 import * as fs from "fs";
 import * as path from "path";
-import { runtimeFile, getProjectDirs } from "./shared.js";
-import { findFtsCacheForPath } from "./shared-index.js";
-import { isValidProjectName, errorMessage } from "./utils.js";
-import { readReviewQueue, readReviewQueueAcrossProjects } from "./data-access.js";
-import { addProjectFromPath } from "./core-project.js";
-import { PROJECT_OWNERSHIP_MODES, parseProjectOwnershipMode } from "./project-config.js";
-import { resolveRuntimeProfile } from "./runtime-profile.js";
-import { getMachineName } from "./machine-identity.js";
-import { getProjectConsolidationStatus, CONSOLIDATION_ENTRY_THRESHOLD } from "./content-validate.js";
+import { runtimeFile, getProjectDirs } from "../shared.js";
+import { findFtsCacheForPath } from "../shared/index.js";
+import { isValidProjectName, errorMessage } from "../utils.js";
+import { readReviewQueue, readReviewQueueAcrossProjects, approveQueueItem, rejectQueueItem, editQueueItem } from "../data/access.js";
+import { addProjectFromPath } from "../core/project.js";
+import { PROJECT_OWNERSHIP_MODES, parseProjectOwnershipMode } from "../project-config.js";
+import { resolveRuntimeProfile } from "../runtime-profile.js";
+import { getMachineName } from "../machine-identity.js";
+import { getProjectConsolidationStatus, CONSOLIDATION_ENTRY_THRESHOLD } from "../content/validate.js";
+import { logger } from "../logger.js";
+import { getRuntimeHealth } from "../governance/policy.js";
+import { countUnsyncedCommits } from "../cli-hooks-git.js";
 export function register(server, ctx) {
     const { phrenPath, profile, withWriteQueue } = ctx;
     // ── add_project ────────────────────────────────────────────────────────────
@@ -49,49 +52,15 @@ export function register(server, ctx) {
             }
         });
     });
-    server.registerTool("get_consolidation_status", {
-        title: "◆ phren · consolidation status",
-        description: "Check whether a project's FINDINGS.md needs consolidation. " +
-            "Returns entry count since last consolidation, threshold, and recommendation.",
-        inputSchema: z.object({
-            project: z.string().optional().describe("Project name. If omitted, checks all projects."),
-        }),
-    }, async ({ project }) => {
-        const projectDirs = project
-            ? (() => {
-                if (!isValidProjectName(project))
-                    return [];
-                const dir = path.join(phrenPath, project);
-                return fs.existsSync(dir) ? [dir] : [];
-            })()
-            : getProjectDirs(phrenPath, profile);
-        if (project && projectDirs.length === 0) {
-            return mcpResponse({ ok: false, error: `Project "${project}" not found.` });
-        }
-        const results = [];
-        for (const dir of projectDirs) {
-            const status = getProjectConsolidationStatus(dir);
-            if (!status)
-                continue;
-            results.push({ ...status, threshold: CONSOLIDATION_ENTRY_THRESHOLD });
-        }
-        if (results.length === 0) {
-            return mcpResponse({ ok: true, message: "No FINDINGS.md files found.", data: { results: [] } });
-        }
-        const lines = results.map(r => `${r.project}: ${r.entriesSince} entries since${r.lastConsolidated ? ` ${r.lastConsolidated}` : " (never consolidated)"}` +
-            `${r.recommended ? " — consolidation recommended" : ""}`);
-        return mcpResponse({
-            ok: true,
-            message: lines.join("\n"),
-            data: { results },
-        });
-    });
     // ── health_check ───────────────────────────────────────────────────────────
     server.registerTool("health_check", {
         title: "◆ phren · health",
-        description: "Return phren health status: version, FTS index status, hook registration, and profile/machine info.",
-        inputSchema: z.object({}),
-    }, async () => {
+        description: "Return phren health status: version, FTS index status, hook registration, profile/machine info, and consolidation status for all projects.",
+        inputSchema: z.object({
+            include_consolidation: z.boolean().optional()
+                .describe("Include consolidation status for all projects (default true)."),
+        }),
+    }, async ({ include_consolidation }) => {
         const activeProfile = (() => {
             try {
                 return resolveRuntimeProfile(phrenPath);
@@ -108,8 +77,7 @@ export function register(server, ctx) {
             version = pkg.version || "unknown";
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG))
-                process.stderr.write(`[phren] healthCheck version: ${errorMessage(err)}\n`);
+            logger.debug("healthCheck version", errorMessage(err));
         }
         // FTS index (lives in /tmpphren-fts-*/, not .runtime/)
         let indexStatus = { exists: false };
@@ -117,27 +85,24 @@ export function register(server, ctx) {
             indexStatus = findFtsCacheForPath(phrenPath, activeProfile);
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG))
-                process.stderr.write(`[phren] healthCheck ftsCacheCheck: ${errorMessage(err)}\n`);
+            logger.debug("healthCheck ftsCacheCheck", errorMessage(err));
         }
         // Hook registration
         let hooksEnabled = false;
         try {
-            const { getHooksEnabledPreference } = await import("./init-preferences.js");
+            const { getHooksEnabledPreference } = await import("../init/preferences.js");
             hooksEnabled = getHooksEnabledPreference(phrenPath);
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG))
-                process.stderr.write(`[phren] healthCheck hooksEnabled: ${errorMessage(err)}\n`);
+            logger.debug("healthCheck hooksEnabled", errorMessage(err));
         }
         let mcpEnabled = false;
         try {
-            const { getMcpEnabledPreference } = await import("./init-preferences.js");
+            const { getMcpEnabledPreference } = await import("../init/preferences.js");
             mcpEnabled = getMcpEnabledPreference(phrenPath);
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG))
-                process.stderr.write(`[phren] healthCheck mcpEnabled: ${errorMessage(err)}\n`);
+            logger.debug("healthCheck mcpEnabled", errorMessage(err));
         }
         // Profile/machine info
         const machineName = (() => {
@@ -145,8 +110,7 @@ export function register(server, ctx) {
                 return getMachineName();
             }
             catch (err) {
-                if ((process.env.PHREN_DEBUG))
-                    process.stderr.write(`[phren] healthCheck machineName: ${errorMessage(err)}\n`);
+                logger.debug("healthCheck machineName", errorMessage(err));
             }
             return undefined;
         })();
@@ -155,24 +119,22 @@ export function register(server, ctx) {
         let proactivity = "high";
         let taskMode = "auto";
         try {
-            const { getWorkflowPolicy } = await import("./governance-policy.js");
+            const { getWorkflowPolicy } = await import("../governance/policy.js");
             const workflowPolicy = getWorkflowPolicy(phrenPath);
             taskMode = workflowPolicy.taskMode;
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG))
-                process.stderr.write(`[phren] healthCheck taskMode: ${errorMessage(err)}\n`);
+            logger.debug("healthCheck taskMode", errorMessage(err));
         }
         let syncIntent;
         try {
-            const { readInstallPreferences } = await import("./init-preferences.js");
+            const { readInstallPreferences } = await import("../init/preferences.js");
             const prefs = readInstallPreferences(phrenPath);
             proactivity = prefs.proactivity || "high";
             syncIntent = prefs.syncIntent;
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG))
-                process.stderr.write(`[phren] healthCheck proactivity: ${errorMessage(err)}\n`);
+            logger.debug("healthCheck proactivity", errorMessage(err));
         }
         // Determine sync status from intent + git remote state
         let syncStatus = "local-only";
@@ -209,6 +171,103 @@ export function register(server, ctx) {
                 syncDetail = "sync was configured but no remote found";
             }
         }
+        let consolidation = null;
+        if (include_consolidation !== false) {
+            try {
+                const projectDirsForConsol = getProjectDirs(phrenPath, activeProfile);
+                const consolResults = [];
+                for (const dir of projectDirsForConsol) {
+                    const status = getProjectConsolidationStatus(dir);
+                    if (!status)
+                        continue;
+                    consolResults.push({ ...status, threshold: CONSOLIDATION_ENTRY_THRESHOLD });
+                }
+                consolidation = consolResults;
+            }
+            catch (err) {
+                logger.debug("healthCheck consolidation", errorMessage(err));
+                consolidation = null;
+            }
+        }
+        const consolSummary = consolidation && consolidation.length > 0
+            ? consolidation.filter(r => r.recommended).length > 0
+                ? `Consolidation: ${consolidation.filter(r => r.recommended).length} project(s) need consolidation`
+                : `Consolidation: all projects OK`
+            : null;
+        // ── Surface RuntimeHealth warnings ────────────────────────────────────
+        const warnings = [];
+        try {
+            const health = getRuntimeHealth(phrenPath);
+            // Unsynced commits
+            const unsynced = health.lastSync?.unsyncedCommits;
+            if (typeof unsynced === "number" && unsynced > 0) {
+                warnings.push(`Unsynced commits: ${unsynced} (last push: ${health.lastSync?.lastPushStatus ?? "unknown"})`);
+            }
+            // Last auto-save error
+            if (health.lastAutoSave?.status === "error") {
+                warnings.push(`Last auto-save failed: ${health.lastAutoSave.detail ?? "unknown error"}`);
+            }
+            // Last push error
+            if (health.lastSync?.lastPushStatus === "error") {
+                warnings.push(`Last push failed: ${health.lastSync.lastPushDetail ?? "unknown error"}`);
+            }
+            // Check live unsynced commit count (may differ from cached value)
+            if (syncStatus === "synced" && (!unsynced || unsynced === 0)) {
+                try {
+                    const liveUnsynced = await countUnsyncedCommits(phrenPath);
+                    if (liveUnsynced > 0) {
+                        warnings.push(`Unsynced commits: ${liveUnsynced} (not yet pushed to remote)`);
+                    }
+                }
+                catch (err) {
+                    logger.debug("healthCheck liveUnsyncedCount", errorMessage(err));
+                }
+            }
+        }
+        catch (err) {
+            logger.debug("healthCheck runtimeHealth", errorMessage(err));
+        }
+        // Check recent sync warnings from background sync
+        try {
+            const syncWarningsPath = runtimeFile(phrenPath, "sync-warnings.jsonl");
+            if (fs.existsSync(syncWarningsPath)) {
+                const lines = fs.readFileSync(syncWarningsPath, "utf8").trim().split("\n").filter(Boolean);
+                const recent = lines.slice(-3); // last 3 warnings
+                for (const line of recent) {
+                    try {
+                        const entry = JSON.parse(line);
+                        if (entry.error) {
+                            warnings.push(`Background sync failed (${entry.at?.slice(0, 16) ?? "unknown"}): ${entry.error}`);
+                        }
+                    }
+                    catch { /* skip malformed lines */ }
+                }
+            }
+        }
+        catch (err) {
+            logger.debug("healthCheck syncWarnings", errorMessage(err));
+        }
+        // Check embedding/LLM availability
+        try {
+            const { getOllamaUrl } = await import("../shared/ollama.js");
+            const ollamaUrl = getOllamaUrl();
+            const hasEmbeddingApi = !!process.env.PHREN_EMBEDDING_API_URL;
+            if (!ollamaUrl && !hasEmbeddingApi) {
+                warnings.push("Embeddings: unavailable (no Ollama or API endpoint configured)");
+            }
+            const hasLlmEndpoint = !!process.env.PHREN_LLM_ENDPOINT;
+            const hasAnthropicKey = !!process.env.ANTHROPIC_API_KEY;
+            const hasOpenAiKey = !!process.env.OPENAI_API_KEY;
+            if (!hasLlmEndpoint && !hasAnthropicKey && !hasOpenAiKey) {
+                warnings.push("LLM features: unavailable (no API key configured for semantic dedup/conflict detection)");
+            }
+        }
+        catch (err) {
+            logger.debug("healthCheck serviceAvailability", errorMessage(err));
+        }
+        const warningsSummary = warnings.length > 0
+            ? `Warnings: ${warnings.length}\n  ${warnings.join("\n  ")}`
+            : null;
         const lines = [
             `Phren v${version}`,
             `Profile: ${activeProfile || "(default)"}`,
@@ -220,6 +279,8 @@ export function register(server, ctx) {
             `Proactivity: ${proactivity}`,
             `Task mode: ${taskMode}`,
             `Sync: ${syncStatus}${syncStatus !== "synced" ? ` (${syncDetail})` : ""}`,
+            consolSummary,
+            warningsSummary,
             `Path: ${phrenPath}`,
         ].filter(Boolean);
         return mcpResponse({
@@ -237,6 +298,8 @@ export function register(server, ctx) {
                 taskMode,
                 syncStatus,
                 syncDetail,
+                consolidation,
+                warnings,
                 phrenPath,
             },
         });
@@ -251,7 +314,7 @@ export function register(server, ctx) {
                 .describe("Also validate data files (tasks, findings, governance). Default false."),
         }),
     }, async ({ check_data }) => {
-        const { runDoctor } = await import("./link-doctor.js");
+        const { runDoctor } = await import("../link/doctor.js");
         const result = await runDoctor(phrenPath, true, check_data ?? false);
         const lines = result.checks.map((c) => `${c.ok ? "ok" : "FAIL"} ${c.name}: ${c.detail}`);
         const failCount = result.checks.filter((c) => !c.ok).length;
@@ -302,8 +365,7 @@ export function register(server, ctx) {
                 return lines.filter(line => ERROR_PATTERNS.some(p => p.test(line)));
             }
             catch (err) {
-                if ((process.env.PHREN_DEBUG))
-                    process.stderr.write(`[phren] readErrorLines: ${errorMessage(err)}\n`);
+                logger.debug("readErrorLines", errorMessage(err));
                 return [];
             }
         }
@@ -360,4 +422,40 @@ export function register(server, ctx) {
             data: { items: result.data },
         });
     });
+    // ── manage_review_item ──────────────────────────────────────────────────
+    server.registerTool("manage_review_item", {
+        title: "◆ phren · manage review item",
+        description: "Manage a review queue item: approve (removes from queue, finding stays), reject (removes from queue AND FINDINGS.md), or edit (updates text in both).",
+        inputSchema: z.object({
+            project: z.string().describe("Project name."),
+            line: z.string().max(10000).describe("The raw queue line text (as returned by get_review_queue)."),
+            action: z.enum(["approve", "reject", "edit"]).describe("Action to perform on the queue item."),
+            new_text: z.string().max(10000).optional().describe("Required when action is 'edit'."),
+        }),
+    }, async ({ project, line, action, new_text }) => {
+        if (!isValidProjectName(project)) {
+            return mcpResponse({ ok: false, error: `Invalid project name: "${project}".` });
+        }
+        if (action === "edit" && !new_text) {
+            return mcpResponse({ ok: false, error: "new_text is required when action is 'edit'." });
+        }
+        return withWriteQueue(async () => {
+            let result;
+            switch (action) {
+                case "approve":
+                    result = approveQueueItem(phrenPath, project, line);
+                    break;
+                case "reject":
+                    result = rejectQueueItem(phrenPath, project, line);
+                    break;
+                case "edit":
+                    result = editQueueItem(phrenPath, project, line, new_text);
+                    break;
+            }
+            if (!result.ok) {
+                return mcpResponse({ ok: false, error: result.error, errorCode: result.code });
+            }
+            return mcpResponse({ ok: true, message: result.data });
+        });
+    });
 }

package/mcp/dist/{mcp-search.js → tools/search.js}

@@ -1,18 +1,19 @@
-import { mcpResponse } from "./mcp-types.js";
+import { mcpResponse } from "./types.js";
 import { z } from "zod";
 import * as fs from "fs";
 import { createHash } from "crypto";
-import { isValidProjectName, errorMessage } from "./utils.js";
-import { readFindings } from "./data-access.js";
-import { debugLog, runtimeFile, DOC_TYPES, FINDING_TAGS, isMemoryScopeVisible, normalizeMemoryScope, } from "./shared.js";
-import { FINDING_LIFECYCLE_STATUSES, parseFindingLifecycle, } from "./shared-content.js";
-import { decodeStringRow, queryRows, queryDocRows, queryEntityLinks, logEntityMiss, extractSnippet, queryDocBySourceKey, normalizeMemoryId, } from "./shared-index.js";
-import { runCustomHooks } from "./hooks.js";
-import { entryScoreKey, getQualityMultiplier, getRetentionPolicy } from "./shared-governance.js";
-import { callLlm } from "./content-dedup.js";
-import { rankResults, searchKnowledgeRows, applyTrustFilter, searchFederatedStores } from "./shared-retrieval.js";
-import { parseSourceComment } from "./content-citation.js";
-import { resolveActiveSessionScope } from "./mcp-session.js";
+import { isValidProjectName, errorMessage } from "../utils.js";
+import { readFindings } from "../data/access.js";
+import { debugLog, runtimeFile, DOC_TYPES, FINDING_TAGS, isMemoryScopeVisible, normalizeMemoryScope, } from "../shared.js";
+import { FINDING_LIFECYCLE_STATUSES, parseFindingLifecycle, } from "../shared/content.js";
+import { decodeStringRow, queryRows, queryDocRows, queryEntityLinks, logEntityMiss, extractSnippet, queryDocBySourceKey, normalizeMemoryId, } from "../shared/index.js";
+import { runCustomHooks } from "../hooks.js";
+import { entryScoreKey, getQualityMultiplier, getRetentionPolicy } from "../shared/governance.js";
+import { callLlm } from "../content/dedup.js";
+import { rankResults, searchKnowledgeRows, applyTrustFilter, searchFederatedStores } from "../shared/retrieval.js";
+import { parseSourceComment } from "../content/citation.js";
+import { resolveActiveSessionScope } from "./session.js";
+import { logger } from "../logger.js";
 /**
  * Q30: Log zero-result queries to .runtime/search-misses.jsonl.
  * Strips PII-like tokens (emails, UUIDs, numbers) and keeps only query terms.
@@ -35,8 +36,7 @@ export function logSearchMiss(phrenPath, query, project) {
         fs.appendFileSync(missFile, entry + "\n");
     }
     catch (err) {
-        if ((process.env.PHREN_DEBUG))
-            process.stderr.write(`[phren] logSearchMiss: ${errorMessage(err)}\n`);
+        logger.debug("search", `logSearchMiss: ${errorMessage(err)}`);
     }
 }
 const HISTORY_FINDING_STATUSES = new Set(["superseded", "retracted"]);
@@ -160,8 +160,7 @@ export function register(server, ctx) {
             createdAt = stat.birthtime.toISOString();
         }
         catch (err) {
-            if ((process.env.PHREN_DEBUG))
-                process.stderr.write(`[phren] search_knowledge statFile: ${errorMessage(err)}\n`);
+            logger.debug("search", `search_knowledge statFile: ${errorMessage(err)}`);
         }
         // Extract tags from content (e.g. [decision], [pitfall], [pattern])
         const tagMatches = doc.content.match(/\[(decision|pitfall|pattern|tradeoff|architecture|bug)\]/gi);
@@ -259,7 +258,7 @@ export function register(server, ctx) {
                 }
                 catch (err) {
                     if (process.env.PHREN_DEBUG) {
-                        process.stderr.write(`[phren] search_knowledge federation: ${errorMessage(err)}\n`);
+                        logger.debug("search", `search_knowledge federation: ${errorMessage(err)}`);
                     }
                 }
             }
@@ -421,8 +420,7 @@ export function register(server, ctx) {
                 relatedFragments = [...new Set(relatedFragments)].slice(0, 10);
             }
             catch (err) {
-                if ((process.env.PHREN_DEBUG))
-                    process.stderr.write(`[phren] fragment query: ${errorMessage(err)}\n`);
+                logger.debug("search", `fragment query: ${errorMessage(err)}`);
             }
             const formatted = results.map((r) => {
                 const fedNote = r.federation_source ? ` [from: ${r.federation_source}]` : "";
@@ -439,8 +437,7 @@ export function register(server, ctx) {
                         synthCache = JSON.parse(fs.readFileSync(synthCachePath, "utf8"));
                     }
                     catch (err) {
-                        if ((process.env.PHREN_DEBUG))
-                            process.stderr.write(`[phren] search_knowledge synthCacheRead: ${errorMessage(err)}\n`);
+                        logger.debug("search", `search_knowledge synthCacheRead: ${errorMessage(err)}`);
                     }
                     const cached = synthCache[synthKey];
                     const SYNTH_CACHE_TTL_MS = 30 * 60 * 1000; // 30 minutes
@@ -464,8 +461,7 @@ export function register(server, ctx) {
                                 fs.writeFileSync(synthCachePath, JSON.stringify(synthCache));
                             }
                             catch (err) {
-                                if ((process.env.PHREN_DEBUG))
-                                    process.stderr.write(`[phren] synthCache write: ${errorMessage(err)}\n`);
+                                logger.debug("search", `synthCache write: ${errorMessage(err)}`);
                             }
                         }
                     }

package/mcp/dist/{mcp-session.js → tools/session.js}

@@ -1,22 +1,23 @@
-import { mcpResponse } from "./mcp-types.js";
+import { mcpResponse } from "./types.js";
 import { z } from "zod";
 import * as fs from "fs";
 import * as path from "path";
 import * as crypto from "crypto";
 import { execFileSync } from "child_process";
-import { debugLog, isMemoryScopeVisible, normalizeMemoryScope } from "./shared.js";
-import { withFileLock } from "./shared-governance.js";
-import { isValidProjectName, errorMessage } from "./utils.js";
-import { runCustomHooks } from "./hooks.js";
-import { readExtractedFacts } from "./mcp-extract-facts.js";
-import { resolveFindingSessionId } from "./finding-context.js";
-import { readTasks } from "./data-tasks.js";
-import { readFindings } from "./data-access.js";
-import { getProjectDirs } from "./shared.js";
-import { getActiveTaskForSession } from "./task-lifecycle.js";
-import { listTaskCheckpoints, writeTaskCheckpoint } from "./session-checkpoints.js";
-import { markImpactEntriesCompletedForSession } from "./finding-impact.js";
-import { atomicWriteJson, debugError, scanSessionFiles } from "./session-utils.js";
+import { debugLog, isMemoryScopeVisible, normalizeMemoryScope } from "../shared.js";
+import { withFileLock } from "../shared/governance.js";
+import { isValidProjectName, errorMessage } from "../utils.js";
+import { runCustomHooks } from "../hooks.js";
+import { readExtractedFacts } from "./extract-facts.js";
+import { resolveFindingSessionId } from "../finding/context.js";
+import { readTasks } from "../data/tasks.js";
+import { readFindings } from "../data/access.js";
+import { getProjectDirs } from "../shared.js";
+import { getActiveTaskForSession } from "../task/lifecycle.js";
+import { listTaskCheckpoints, writeTaskCheckpoint } from "../session/checkpoints.js";
+import { markImpactEntriesCompletedForSession } from "../finding/impact.js";
+import { atomicWriteJson, debugError, scanSessionFiles } from "../session/utils.js";
+import { getRuntimeHealth } from "../governance/policy.js";
 const STALE_SESSION_MS = 24 * 60 * 60 * 1000; // 24 hours
 function collectGitStatusSnapshot(cwd) {
     try {
@@ -215,6 +216,10 @@ function cleanupStaleSessions(phrenPath) {
     let cleaned = 0;
     for (const { fullPath, data: state } of results) {
         try {
+            // Only clean up sessions that have ended (have endedAt). Active sessions
+            // (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()
@@ -403,16 +408,15 @@ export function register(server, ctx) {
         if (agentScope !== undefined && !normalizedAgentScope) {
             return mcpResponse({ ok: false, error: `Invalid agentScope: "${agentScope}". Use lowercase letters/numbers with '-' or '_' (max 64 chars).` });
         }
-        // Find most recent prior session for context
+        // Find most recent prior session for context.
+        // When no explicit project is provided, prefer the last ENDED session's
+        // project (completed context) over an active session from a different client.
+        const priorEnded = findMostRecentSummaryWithProject(phrenPath);
         const priorResult = findMostRecentSession(phrenPath);
         const prior = priorResult?.state ?? null;
-        // Also check ended sessions for summaries and project context.
-        // findMostRecentSession skips ended sessions, so we need a separate lookup
-        // to restore project context after a normal session_end.
-        const priorEnded = prior ? null : findMostRecentSummaryWithProject(phrenPath);
-        const priorSummary = prior?.summary ?? priorEnded?.summary ?? null;
-        const priorProject = prior?.project ?? priorEnded?.project;
-        const priorEndedAt = prior?.endedAt ?? priorEnded?.endedAt;
+        const priorSummary = priorEnded?.summary ?? prior?.summary ?? null;
+        const priorProject = priorEnded?.project ?? prior?.project;
+        const priorEndedAt = priorEnded?.endedAt ?? prior?.endedAt;
         // Create new session with unique ID in its own file
         const sessionId = crypto.randomUUID();
         const next = {
@@ -521,10 +525,31 @@ export function register(server, ctx) {
                 debugError("session_start contextDiff", err);
             }
         }
+        // ── Surface sync/health warnings ────────────────────────────────────
+        const sessionWarnings = [];
+        try {
+            const health = getRuntimeHealth(phrenPath);
+            if (health.lastAutoSave?.status === "error") {
+                sessionWarnings.push(`Last auto-save failed: ${health.lastAutoSave.detail ?? "unknown"}`);
+            }
+            if (health.lastSync?.lastPushStatus === "error") {
+                sessionWarnings.push(`Last push failed: ${health.lastSync.lastPushDetail ?? "unknown"}`);
+            }
+            const unsynced = health.lastSync?.unsyncedCommits;
+            if (typeof unsynced === "number" && unsynced > 0) {
+                sessionWarnings.push(`${unsynced} unsynced commit${unsynced === 1 ? "" : "s"} — run 'phren doctor' or check git remote`);
+            }
+        }
+        catch (err) {
+            debugError("session_start runtimeHealth", err);
+        }
+        if (sessionWarnings.length > 0) {
+            parts.push(`## Sync warnings\n${sessionWarnings.map(w => `- ${w}`).join("\n")}`);
+        }
         const message = parts.length > 0
             ? `Session started (${sessionId.slice(0, 8)}).\n\n${parts.join("\n\n")}`
             : `Session started (${sessionId.slice(0, 8)}). No prior context found.`;
-        return mcpResponse({ ok: true, message, data: { sessionId, project: activeProject, agentScope: activeScope } });
+        return mcpResponse({ ok: true, message, data: { sessionId, project: activeProject, agentScope: activeScope, warnings: sessionWarnings.length > 0 ? sessionWarnings : undefined } });
     });
     server.registerTool("session_end", {
         title: "◆ phren · session end",

package/mcp/dist/{mcp-skills.js → tools/skills.js}

@@ -1,11 +1,11 @@
-import { mcpResponse } from "./mcp-types.js";
+import { mcpResponse } from "./types.js";
 import { z } from "zod";
 import * as fs from "fs";
 import * as path from "path";
-import { isValidProjectName, safeProjectPath } from "./utils.js";
-import { parseSkillFrontmatter, validateSkillFrontmatter } from "./link-skills.js";
-import { removeSkillPath, setSkillEnabledAndSync } from "./skill-files.js";
-import { buildSkillManifest, findLocalSkill, findSkill, getAllSkills } from "./skill-registry.js";
+import { isValidProjectName, safeProjectPath } from "../utils.js";
+import { parseSkillFrontmatter, validateSkillFrontmatter } from "../link/skills.js";
+import { removeSkillPath, setSkillEnabledAndSync } from "../skill/files.js";
+import { buildSkillManifest, findLocalSkill, findSkill, getAllSkills } from "../skill/registry.js";
 export function register(server, ctx) {
     const { phrenPath, profile, withWriteQueue, updateFileInIndex } = ctx;
     // ── list_skills ──────────────────────────────────────────────────────────
@@ -165,36 +165,34 @@ export function register(server, ctx) {
             return mcpResponse({ ok: true, message: `Removed skill "${name}" (${removedPath}).`, data: { path: removedPath } });
         });
     });
-    for (const action of [
-        { tool: "enable_skill", enabled: true, verb: "Enable" },
-        { tool: "disable_skill", enabled: false, verb: "Disable" },
-    ]) {
-        server.registerTool(action.tool, {
-            title: `◆ phren · ${action.enabled ? "enable" : "disable"} skill`,
-            description: `${action.verb} a skill without deleting its file.`,
-            inputSchema: z.object({
-                name: z.string().describe("Skill name (without .md)."),
-                project: z.string().describe("Project scope or 'global'."),
-            }),
-        }, async ({ name, project }) => {
-            if (project.toLowerCase() !== "global" && !isValidProjectName(project)) {
-                return mcpResponse({ ok: false, error: `Invalid project name: "${project}"` });
-            }
-            const result = findSkill(phrenPath, profile, project, name);
-            if (!result) {
-                return mcpResponse({ ok: false, error: `Skill "${name}" not found in "${project}".` });
-            }
-            if ("error" in result) {
-                return mcpResponse({ ok: false, error: result.error });
-            }
-            return withWriteQueue(async () => {
-                setSkillEnabledAndSync(phrenPath, project, result.name, action.enabled);
-                return mcpResponse({
-                    ok: true,
-                    message: `${action.verb}d skill "${result.name}" in ${project}.`,
-                    data: { name: result.name, project, enabled: action.enabled },
-                });
+    // ── toggle_skill ─────────────────────────────────────────────────────
+    server.registerTool("toggle_skill", {
+        title: "◆ phren · toggle skill",
+        description: "Enable or disable a skill without deleting its file.",
+        inputSchema: z.object({
+            name: z.string().describe("Skill name (without .md)."),
+            enabled: z.boolean().describe("true to enable, false to disable."),
+            project: z.string().describe("Project scope or 'global'."),
+        }),
+    }, async ({ name, enabled, project }) => {
+        if (project.toLowerCase() !== "global" && !isValidProjectName(project)) {
+            return mcpResponse({ ok: false, error: `Invalid project name: "${project}"` });
+        }
+        const result = findSkill(phrenPath, profile, project, name);
+        if (!result) {
+            return mcpResponse({ ok: false, error: `Skill "${name}" not found in "${project}".` });
+        }
+        if ("error" in result) {
+            return mcpResponse({ ok: false, error: result.error });
+        }
+        const verb = enabled ? "Enable" : "Disable";
+        return withWriteQueue(async () => {
+            setSkillEnabledAndSync(phrenPath, project, result.name, enabled);
+            return mcpResponse({
+                ok: true,
+                message: `${verb}d skill "${result.name}" in ${project}.`,
+                data: { name: result.name, project, enabled },
             });
         });
-    }
+    });
 }