logwork-cli 1.1.1 → 1.3.0

package/lib/commit-workflow.mjs

@@ -3,16 +3,34 @@ import { homedir } from 'node:os';
 import { resolve } from 'node:path';
 import { isAuthRequiredError } from './auth-errors.mjs';
 import { CONFIG } from './config.mjs';
-import { normalizeQueryRange, queryLogwork } from './query-workflow.mjs';
+import { findRepoMapping, loadLocalConfig } from './logwork-config.mjs';
+import { projectIdentityKey, sameProjectIdentity } from './project-identity.mjs';
+import { resolveEntryProject } from './project-resolver.mjs';
+import {
+  createMembershipProjectsFetcher,
+  normalizeQueryRange,
+  queryLogwork
+} from './query-workflow.mjs';
+import {
+  bookedProjectsByDateFromQuery,
+  historyFromQueryResult,
+  suggestRepoProjects
+} from './repo-project-suggestions.mjs';
 import { addLocalDays, todayLocalDateISO } from './util.mjs';
 
 // Builds a logwork draft from the user's own git commits:
 //   commits (all branches, this author, in the period)
 //   -> grouped per day by repo + ticket + kind of work
 //   -> each group gets a default RO worklog task and a description
-//   -> the day's hours (RO booked - logged, or a standard day) are split across
-//      groups by how much work each group holds
-//   -> a "+<hours> <worklog task> | <description>" block for log_work.
+//   -> each group gets an RO project: a mapping whose repos list holds the
+//      repo, else the project resolver (tickets, keywords, booked projects)
+//   -> each project's remaining hours (RO booked - logged) are split across its
+//      groups by how much work each group holds; unresolved groups share the
+//      room of booked projects no group claimed (without RO: a standard day)
+//   -> a "+<hours> <worklog task> | <description>" block for log_work
+//   -> for each repo whose lines got no project, ranked project suggestions
+//      (ticket history, repo/remote name, single booked project) so the user
+//      can confirm one and map the repo once.
 // Nothing is written anywhere; the agent shows the draft, the user edits and
 // approves it, then log_work previews and applies it as usual.
 
@@ -25,6 +43,7 @@ const CONVENTIONAL_RE = /^(\w+)(?:\([^)]*\))?!?:\s*/;
 const FIELD = '\x1f';
 const RECORD = '\x1e';
 const MAX_DESCRIPTION_LENGTH = 240;
+const SUGGESTION_HISTORY_DAYS = 30;
 
 // Default RO catalog task per kind of work. These are the shared default task
 // names; a project with its own catalog may need a different name (list_tasks).
@@ -115,8 +134,16 @@ export function parseGitLog(output = '') {
   return commits;
 }
 
+export async function resolveGitRepoRoot(path, runGit = runGitCommand) {
+  const root = String(await runGit(path, ['rev-parse', '--show-toplevel'])).trim();
+  if (!root) {
+    throw new Error('git did not report a repository root');
+  }
+  return resolve(root);
+}
+
 export async function readRepoCommits({ repo, from, to, author, runGit = runGitCommand }) {
-  const root = (await runGit(repo, ['rev-parse', '--show-toplevel'])).trim();
+  const root = await resolveGitRepoRoot(repo, runGit);
   const authorFilter = (author || (await runGit(root, ['config', 'user.email']).catch(() => ''))).trim();
   if (!authorFilter) {
     throw new Error(`No git author for ${root}. Set git config user.email or pass author.`);
@@ -285,31 +312,111 @@ function isWeekend(localDateISO) {
 }
 
 // Remaining RO time per day: sum over projects of max(0, booked - logged), so
-// over-logging one project does not hide a gap on another.
+// over-logging one project does not hide a gap on another. projects keeps every
+// booked project with its ids so commit groups can be allocated per project.
 export function remainingHoursByDay(roResult) {
   const byDay = new Map();
   for (const day of roResult?.days || []) {
-    const projects = day.projects || [];
+    const projects = (day.projects || []).map((project) => ({
+      ...projectRef(project),
+      bookedHours: Number(project.bookedHours || 0),
+      loggedHours: Number(project.loggedHours || 0),
+      remainingHours: roundHours(Math.max(0, Number(project.bookedHours || 0) - Number(project.loggedHours || 0)))
+    }));
     const remaining = projects.length
-      ? projects.reduce((sum, project) => sum + Math.max(0, Number(project.bookedHours || 0) - Number(project.loggedHours || 0)), 0)
+      ? projects.reduce((sum, project) => sum + project.remainingHours, 0)
       : Math.max(0, Number(day.bookedHours || 0) - Number(day.loggedHours || 0));
     byDay.set(day.date, {
       bookedHours: Number(day.bookedHours || 0),
       loggedHours: Number(day.loggedHours || 0),
-      remainingHours: Number(remaining.toFixed(2)),
-      // The draft does not know which project a commit belongs to; this lets
-      // the agent move lines to the projects that still have room.
+      remainingHours: roundHours(remaining),
+      projects,
       remainingByProject: projects
-        .map((project) => ({
-          projectName: project.projectName,
-          remainingHours: Number(Math.max(0, Number(project.bookedHours || 0) - Number(project.loggedHours || 0)).toFixed(2))
-        }))
         .filter((project) => project.remainingHours > 0)
+        .map((project) => ({ ...projectRef(project), remainingHours: project.remainingHours }))
     });
   }
   return byDay;
 }
 
+// The project of one commit group: a mapping whose repos list holds the repo,
+// else the shared resolver on the description and tickets against the day's
+// booked projects and the ticket/keyword mappings, else null.
+export function resolveGroupProject(group, { bookedProjects = [], config = {}, platform = process.platform } = {}) {
+  const mapping = findRepoMapping(config.projectMappings, group.repo, platform);
+  if (mapping) {
+    const booked = bookedProjects.find((project) => sameProjectIdentity(project, mapping));
+    return { ...projectRef(booked || mapping), source: 'repo_mapping' };
+  }
+  if (!bookedProjects.length) {
+    return null;
+  }
+  const resolution = resolveEntryProject({
+    entry: { id: group.repo, text: group.description, taskName: group.description, tickets: group.tickets },
+    projects: bookedProjects,
+    config
+  });
+  if (resolution.status !== 'resolved') {
+    return null;
+  }
+  return { ...projectRef(resolution.project), source: 'resolver', reason: resolution.reason };
+}
+
+// Splits one day's RO room per project:
+// - groups resolved to a project share that project's remaining hours;
+// - unresolved groups share the remaining hours of booked projects that got
+//   no resolved group;
+// - nothing ever exceeds a project's remaining hours.
+export function allocateDayByProject(groups, projects) {
+  const hours = new Array(groups.length).fill(0);
+  const byProject = new Map();
+  const unresolved = [];
+  groups.forEach((group, index) => {
+    if (!group.project) {
+      unresolved.push(index);
+      return;
+    }
+    const key = projectIdentityKey(group.project);
+    const entry = byProject.get(key) || { project: group.project, indexes: [] };
+    entry.indexes.push(index);
+    byProject.set(key, entry);
+  });
+
+  const claimed = new Set();
+  const allocation = [];
+  for (const { project, indexes } of byProject.values()) {
+    const booked = projects.find((candidate) => sameProjectIdentity(candidate, project));
+    if (booked) {
+      claimed.add(booked);
+    }
+    const remainingHours = booked?.remainingHours ?? 0;
+    const split = allocateHours(indexes.map((index) => groups[index]), remainingHours);
+    indexes.forEach((index, position) => { hours[index] = split[position]; });
+    allocation.push({
+      ...projectRef(project),
+      booked: Boolean(booked),
+      remainingHours,
+      allocatedHours: roundHours(split.reduce((sum, value) => sum + value, 0)),
+      groupCount: indexes.length
+    });
+  }
+
+  const unclaimedHours = roundHours(projects
+    .filter((project) => !claimed.has(project))
+    .reduce((sum, project) => sum + project.remainingHours, 0));
+  if (unresolved.length) {
+    const split = allocateHours(unresolved.map((index) => groups[index]), unclaimedHours);
+    unresolved.forEach((index, position) => { hours[index] = split[position]; });
+  }
+  return {
+    hours,
+    allocation,
+    unresolved: unresolved.length
+      ? { groupCount: unresolved.length, roomHours: unclaimedHours, allocatedHours: roundHours(unresolved.reduce((sum, index) => sum + hours[index], 0)) }
+      : null
+  };
+}
+
 export async function draftLogworkFromCommits({
   period = 'today',
   from,
@@ -319,7 +426,13 @@ export async function draftLogworkFromCommits({
   useBookings = true,
   cwd = process.cwd(),
   runGit = runGitCommand,
-  queryRo = queryLogwork
+  queryRo = queryLogwork,
+  loadConfig = loadLocalConfig,
+  platform = process.platform,
+  suggestProjects = true,
+  fetchProjects,
+  historyDays = SUGGESTION_HISTORY_DAYS,
+  today = todayLocalDateISO()
 } = {}) {
   const range = from || to ? normalizeQueryRange({ from, to }) : normalizeQueryRange({ period });
   const repoPaths = [...new Set((repos?.length ? repos : [cwd]).map((repo) => resolve(cwd, expandHome(String(repo)))))];
@@ -360,14 +473,20 @@ export async function draftLogworkFromCommits({
     }
   }
 
+  const config = commits.length ? await loadConfig(cwd) : { projectMappings: [] };
+
   const days = [];
   for (let date = range.from; date < range.to; date = addLocalDays(date, 1)) {
     const dayCommits = commits.filter((commit) => commit.date === date);
     if (!dayCommits.length) {
       continue;
     }
-    const groups = groupCommits(dayCommits);
     const booking = bookings?.get(date);
+    const bookedProjects = (booking?.projects || []).filter((project) => project.bookedHours > 0);
+    const groups = groupCommits(dayCommits).map((group) => ({
+      ...group,
+      project: resolveGroupProject(group, { bookedProjects, config, platform })
+    }));
     let targetHours;
     let hoursSource;
     if (booking) {
@@ -381,12 +500,19 @@ export async function draftLogworkFromCommits({
       targetHours = isWeekend(date) ? 0 : (CONFIG.standardDayHours || 8);
       hoursSource = isWeekend(date) ? 'weekend' : 'standard_day';
     }
-    const hours = allocateHours(groups, targetHours);
+    // Per-project split only when RO returned identifiable per-project rows
+    // for the day; otherwise (RO unavailable, no booking, day-level totals or
+    // nameless rows) the day's target is split across all groups as before.
+    const perProject = Boolean(booking?.projects?.length) &&
+      booking.projects.every((project) => projectIdentityKey(project) !== '');
+    const split = perProject ? allocateDayByProject(groups, booking.projects) : null;
+    const hours = split ? split.hours : allocateHours(groups, targetHours);
     days.push({
       date,
       targetHours,
       hoursSource,
       ...(booking ? { bookedHours: booking.bookedHours, loggedHours: booking.loggedHours, remainingByProject: booking.remainingByProject } : {}),
+      ...(split ? { projectAllocation: split.allocation, unresolvedAllocation: split.unresolved } : {}),
       groups: groups.map((group, index) => ({
         hours: hours[index],
         task: group.task,
@@ -394,6 +520,8 @@ export async function draftLogworkFromCommits({
         description: group.description,
         tickets: group.tickets,
         repo: group.repoName,
+        repoPath: group.repo,
+        project: group.project,
         commitCount: group.commitCount,
         linesChanged: group.linesChanged,
         commits: group.hashes
@@ -401,15 +529,51 @@ export async function draftLogworkFromCommits({
     });
   }
 
+  // log_work preview entry ids are "<date>-<NN>", NN counting entry lines
+  // through the whole text (lib/batch-parser.mjs), so they are numbered here in
+  // the same order the lines are written.
+  const projectOverrides = {};
+  let lineIndex = 0;
   const draftText = days
     .map((day) => {
-      const lines = day.groups.filter((group) => group.hours > 0)
-        .map((group) => `+${group.hours} ${group.task} | ${group.description}`);
+      const lines = [];
+      for (const group of day.groups.filter((item) => item.hours > 0)) {
+        lineIndex += 1;
+        const entryId = `${day.date}-${String(lineIndex).padStart(2, '0')}`;
+        group.entryId = entryId;
+        if (hasValue(group.project?.projectMemberId)) {
+          projectOverrides[entryId] = group.project.projectMemberId;
+        }
+        lines.push(`+${group.hours} ${group.task} | ${group.description}`);
+      }
       return lines.length ? [formatDayHeading(day.date), ...lines].join('\n') : '';
     })
     .filter(Boolean)
     .join('\n\n');
 
+  const unmappedRepos = [...new Set(days.flatMap((day) => day.groups)
+    .filter((group) => !group.project)
+    .map((group) => group.repoPath))];
+
+  // Suggestions need RO (candidates and history), so they are skipped when the
+  // bookings were not read.
+  const suggestions = unmappedRepos.length && bookings && suggestProjects
+    ? await buildRepoSuggestions({
+      unmappedRepos,
+      days,
+      bookings,
+      queryRo,
+      // Memberships come from the same source as the bookings: a caller that
+      // injects queryRo (tests, other workflows) gets none unless it injects
+      // fetchProjects too, so it never reaches the real RO.
+      fetchProjects: fetchProjects || (queryRo === queryLogwork ? createMembershipProjectsFetcher() : async () => []),
+      runGit,
+      cwd,
+      today,
+      historyDays
+    })
+    : { repoSuggestions: {}, projectCandidates: [] };
+
   const result = {
     status: !commits.length ? 'no_commits' : (draftText ? 'draft' : 'no_hours'),
     range,
@@ -418,7 +582,11 @@ export async function draftLogworkFromCommits({
     ...(bookingsError ? { bookingsError } : {}),
     commitCount: commits.length,
     days,
-    draftText
+    draftText,
+    projectOverrides,
+    unmappedRepos,
+    repoSuggestions: suggestions.repoSuggestions,
+    projectCandidates: suggestions.projectCandidates
   };
   result.summary = formatCommitDraftSummary(result);
   return result;
@@ -446,18 +614,172 @@ export function formatCommitDraftSummary(result) {
     }[day.hoursSource];
     lines.push('', `${formatDayHeading(day.date)} - ${source}`);
     if (day.remainingByProject?.length) {
-      lines.push(`  Room by project: ${day.remainingByProject.map((project) => `${project.projectName} ${project.remainingHours}h`).join(', ')}`);
+      lines.push(`  Room by project: ${day.remainingByProject.map((project) => `${projectLabel(project)} ${project.remainingHours}h`).join(', ')}`);
+    }
+    for (const project of day.projectAllocation || []) {
+      if (project.allocatedHours === 0) {
+        lines.push(`  No room on ${projectLabel(project)}${project.booked ? ` (remaining ${project.remainingHours}h)` : ' (not booked this day)'}: its ${project.groupCount} line(s) get 0h.`);
+      }
+    }
+    if (day.unresolvedAllocation) {
+      lines.push(`  ${day.unresolvedAllocation.groupCount} line(s) without a project share ${day.unresolvedAllocation.roomHours}h left on booked projects no other line claimed.`);
     }
     for (const group of day.groups) {
-      lines.push(`  +${group.hours} ${group.task} | ${group.description}  [${group.repo}, ${group.commitCount} commit(s)]`);
+      const project = group.project
+        ? `${projectLabel(group.project)} (${group.project.source === 'repo_mapping' ? 'repo mapping' : group.project.reason || group.project.source})`
+        : 'project unresolved';
+      lines.push(`  ${group.entryId ? `${group.entryId} ` : ''}+${group.hours} ${group.task} | ${group.description}  [${group.repo}, ${group.commitCount} commit(s)] -> ${project}`);
     }
   }
   if (result.draftText) {
     lines.push('', 'Draft for log_work (review with the user first; worklog task names must exist in list_tasks for the project):', '', result.draftText);
+    if (Object.keys(result.projectOverrides || {}).length) {
+      lines.push('', `Pass projectOverrides to log_work with this draftText unchanged (renumbered or edited lines need new ids): ${JSON.stringify(result.projectOverrides)}`);
+    }
+  }
+  if (result.unmappedRepos?.length) {
+    lines.push('', 'No project for the lines of these repos. Confirm each repo\'s RO project once (logwork commits asks in a terminal; /map --repo in the terminal UI; agents call map_project with projectName and repos):');
+    for (const repo of result.unmappedRepos) {
+      const top = result.repoSuggestions?.[repo]?.[0];
+      lines.push(top
+        ? `- ${repo}: likely ${projectLabel(top)} (${top.reasons.join('; ')})`
+        : `- ${repo}: no suggestion; ask which project it belongs to`);
+    }
   }
   return lines.join('\n');
 }
 
+// Ranked project suggestions per unmapped repo. RO history and memberships
+// are read once per draft and are best effort: an auth error still reaches the
+// caller (authRequired), any other error only drops that evidence.
+async function buildRepoSuggestions({ unmappedRepos, days, bookings, queryRo, fetchProjects, runGit, cwd, today, historyDays }) {
+  const historyResult = await bestEffort(() => queryRo({
+    from: addLocalDays(today, -historyDays),
+    to: addLocalDays(today, 1),
+    includeEntries: true,
+    cwd
+  }));
+  const memberships = await bestEffort(fetchProjects);
+  const projectCandidates = mergeCandidates([
+    ...[...bookings.values()].flatMap((day) => day.projects.filter((project) => project.bookedHours > 0)),
+    ...(Array.isArray(memberships) ? memberships : [])
+  ]);
+  const history = historyFromQueryResult(historyResult);
+  const bookedProjectsByDate = {};
+  for (const [date, day] of bookings) {
+    bookedProjectsByDate[date] = day.projects.filter((project) => project.bookedHours > 0);
+  }
+
+  const repoSuggestions = {};
+  for (const repo of unmappedRepos) {
+    const repoGroups = days.flatMap((day) => day.groups
+      .filter((group) => group.repoPath === repo && !group.project)
+      .map((group) => ({ ...group, date: day.date })));
+    repoSuggestions[repo] = suggestRepoProjects({
+      repoPath: repo,
+      repoGroups,
+      candidates: projectCandidates,
+      history,
+      remoteUrl: await readRemoteUrl(repo, runGit),
+      bookedProjectsByDate
+    });
+  }
+  return { repoSuggestions, projectCandidates };
+}
+
+// Suggestions for one repo outside a draft (the terminal UI /map picker): the
+// last historyDays of the repo's commits, RO entries and bookings, ranked
+// against the given member projects.
+export async function suggestProjectsForRepo({
+  repo,
+  projects = [],
+  author,
+  cwd = process.cwd(),
+  runGit = runGitCommand,
+  queryRo = queryLogwork,
+  historyDays = SUGGESTION_HISTORY_DAYS,
+  today = todayLocalDateISO()
+} = {}) {
+  const repoPath = resolve(cwd, expandHome(String(repo || '.')));
+  const root = await resolveGitRepoRoot(repoPath, runGit);
+  const from = addLocalDays(today, -historyDays);
+  const to = addLocalDays(today, 1);
+  const commits = await readRepoCommits({ repo: root, from, to, author, runGit })
+    .then((result) => result.commits)
+    .catch(() => []);
+  const repoGroups = [...new Set(commits.map((commit) => commit.date))]
+    .flatMap((date) => groupCommits(commits.filter((commit) => commit.date === date)).map((group) => ({ ...group, date })));
+  const historyResult = await bestEffort(() => queryRo({ from, to, includeEntries: true, cwd }));
+  const candidates = mergeCandidates(projects);
+  return {
+    repoRoot: root,
+    candidates,
+    suggestions: suggestRepoProjects({
+      repoPath: root,
+      repoGroups,
+      candidates,
+      history: historyFromQueryResult(historyResult),
+      remoteUrl: await readRemoteUrl(root, runGit),
+      bookedProjectsByDate: bookedProjectsByDateFromQuery(historyResult)
+    })
+  };
+}
+
+export async function readRemoteUrl(repo, runGit = runGitCommand) {
+  try {
+    return String(await runGit(repo, ['remote', 'get-url', 'origin'])).trim();
+  } catch {
+    return '';
+  }
+}
+
+async function bestEffort(action) {
+  try {
+    return await action();
+  } catch (error) {
+    if (isAuthRequiredError(error)) {
+      throw error;
+    }
+    return null;
+  }
+}
+
+function mergeCandidates(projects) {
+  const results = [];
+  for (const project of projects) {
+    if (!project || !(project.projectName || hasValue(project.projectMemberId))) {
+      continue;
+    }
+    const known = results.findIndex((candidate) => sameProjectIdentity(candidate, project));
+    if (known < 0) {
+      results.push(projectRef(project));
+    } else {
+      results[known] = { ...projectRef(project), ...results[known] };
+    }
+  }
+  return results;
+}
+
+function projectRef(project = {}) {
+  return {
+    projectName: project.projectName || '',
+    ...(hasValue(project.projectMemberId) ? { projectMemberId: project.projectMemberId } : {}),
+    ...(hasValue(project.projectId) ? { projectId: project.projectId } : {})
+  };
+}
+
+function projectLabel(project = {}) {
+  return project.projectName || (hasValue(project.projectMemberId) ? `project member ${project.projectMemberId}` : 'unnamed project');
+}
+
+function hasValue(value) {
+  return value !== undefined && value !== null && String(value).trim() !== '';
+}
+
+function roundHours(value) {
+  return Number(Number(value || 0).toFixed(2));
+}
+
 function expandHome(path) {
   return path === '~' || /^~[\\/]/.test(path) ? `${homedir()}${path.slice(1)}` : path;
 }

package/lib/config.mjs

@@ -45,6 +45,13 @@ const BASE_CONFIG = {
 
 export const CONFIG = buildConfig(process.env);
 
+// LOGWORK_DRY_RUN=1 turns every RO and Jira write into a returned request
+// ({ dryRun: true, method, path, body }). Read at call time so tests and the
+// MCP server can toggle it without reloading CONFIG. Reads still hit the API.
+export function isDryRun(env = process.env) {
+  return env.LOGWORK_DRY_RUN === '1';
+}
+
 export function buildConfig(env = {}) {
   const profile = readStringEnv(env, 'LOGWORK_PROFILE') || readStringEnv(env, 'LOGWORK_HELPER_PROFILE') || DEFAULT_PROFILE;
   const config = {

package/lib/diagnostics.mjs

@@ -1,4 +1,3 @@
-import { spawn } from 'node:child_process';
 import { constants as fsConstants } from 'node:fs';
 import { access, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
 import { EOL, homedir, platform, release, type } from 'node:os';
@@ -11,7 +10,11 @@ import { getStoredAuthStatus } from './auth.mjs';
 import { redactText } from './auth-redaction.mjs';
 import { authDebugLogPath, sanitizeDiagnosticValue } from './auth-diagnostics.mjs';
 import { configPath, loadLocalConfig } from './logwork-config.mjs';
-import { helperHome, manualDraftsPath, userConfigPath } from './paths.mjs';
+import { checkLaunchCommand, formatLaunchCheckIssue, resolveLaunchCommand } from './launcher.mjs';
+import { createMcpInstallContext, inspectMcpClients } from './mcp-install.mjs';
+import { formatNodePathIssue, inspectNodePath, inspectScheduledCommand, loadRuntimeInfo } from './node-runtime.mjs';
+import { helperHome, manualDraftsPath, runtimeInfoPath, userConfigPath } from './paths.mjs';
+import { readReminderSchedulerNodePath } from './reminder-scheduler.mjs';
 
 const DIAGNOSTICS_DIR_NAME = 'diagnostics';
 const MAX_AUTH_DEBUG_CHARS = 20_000;
@@ -35,6 +38,8 @@ export async function generateDiagnosticsReport({
   commandFinder = findCommandOnPath,
   authStatusFn = getStoredAuthStatus,
   mcpSmokeFn = runMcpSmoke,
+  nodeRuntimeFn = collectNodeRuntimeCheck,
+  mcpClientsFn = collectMcpClientCheck,
   readFileFn = readFile,
   statFn = stat,
   writeFileFn = writeFile,
@@ -47,6 +52,13 @@ export async function generateDiagnosticsReport({
   const fileChecks = await collectFileChecks({ statFn, cwd });
   const configSnapshot = await safeCollect('config snapshot', () => collectConfigSnapshot({ cwd, includeMappingDetails }));
   const mcpSmoke = await safeCollect('mcp smoke', () => mcpSmokeFn({ cwd }));
+  const nodeRuntime = await safeCollect('node runtime', () => nodeRuntimeFn());
+  const mcpClients = await safeCollect('mcp clients', () => mcpClientsFn());
+  const runtimeIssues = Array.isArray(nodeRuntime?.issues) ? nodeRuntime.issues : [];
+  const mcpIssues = (Array.isArray(mcpClients) ? mcpClients : [])
+    .filter((client) => client.status === 'stale' || client.legacy || client.localScopes)
+    .map((client) => `MCP: ${formatMcpClientCheck(client)}. Fix: run \`logwork mcp install\`.`);
+  const nodeIssues = [...runtimeIssues, ...mcpIssues];
   const authDebug = await readSanitizedAuthDebug({ readFileFn });
 
   sections.push(formatSection('logwork-cli Diagnostics', [
@@ -64,6 +76,30 @@ export async function generateDiagnosticsReport({
     `home: ${homedir()}`
   ]));
 
+  sections.push(formatSection('Node Path', nodeRuntime?.ok === false
+    ? formatObjectLines(nodeRuntime)
+    : [
+      `runtimeFile: ${nodeRuntime.runtimeFile}`,
+      ...(nodeRuntime.launchCommand ? [
+        `launchCommand: ${nodeRuntime.launchCommand}`,
+        `launchStatus: ${nodeRuntime.launchStatus}`,
+        `launchNode: ${nodeRuntime.launchNode || 'unknown'}`,
+        `launchVersion: ${nodeRuntime.launchVersion || 'unknown'}`
+      ] : []),
+      `recordedNode: ${nodeRuntime.recordedNode || 'none (run logwork setup)'}${nodeRuntime.recordedVersion ? ` (${nodeRuntime.recordedVersion})` : ''}`,
+      `recordedNodeStatus: ${nodeRuntime.recordedStatus}${nodeRuntime.recordedNote ? ` (${nodeRuntime.recordedNote})` : ''}`,
+      `reminderNode: ${nodeRuntime.reminderNode || 'none (no reminder schedule)'}`,
+      `reminderNodeStatus: ${nodeRuntime.reminderStatus}`,
+      ...(runtimeIssues.length ? runtimeIssues.map((issue) => `warning: ${issue}`) : ['warnings: none'])
+    ]));
+
+  sections.push(formatSection('MCP Clients', Array.isArray(mcpClients)
+    ? [
+      ...(mcpClients.length ? mcpClients.map(formatMcpClientCheck) : ['none detected']),
+      ...mcpIssues.map((issue) => `warning: ${issue}`)
+    ]
+    : formatObjectLines(mcpClients)));
+
   sections.push(formatSection('Commands', commandChecks.map((entry) => `${entry.command}: ${entry.available ? 'found' : 'missing'}${entry.path ? ` (${entry.path})` : ''}`)));
   sections.push(formatSection('Files', fileChecks.map((entry) => formatFileCheck(entry))));
   sections.push(formatSection('Config Snapshot', formatObjectLines(configSnapshot)));
@@ -78,10 +114,86 @@ export async function generateDiagnosticsReport({
   return {
     path: outputPath,
     report,
-    summary: `Diagnostics report written to ${outputPath}`
+    nodeIssues: nodeIssues.map((issue) => sanitizeReport(issue)),
+    summary: [
+      ...nodeIssues.map((issue) => sanitizeReport(`Warning: ${issue}`)),
+      `Diagnostics report written to ${outputPath}`
+    ].join(EOL)
+  };
+}
+
+// Checks the launch command IDE configs and the reminder run (it must exist
+// and start a usable Node), the node recorded by `logwork setup`
+// (runtime.json) and the command in the installed reminder schedule.
+// Read-only: it only runs the launch command with --version.
+export async function collectNodeRuntimeCheck({
+  launch = resolveLaunchCommand(),
+  loadRuntime = loadRuntimeInfo,
+  readSchedulerNodePath = readReminderSchedulerNodePath,
+  inspect = inspectNodePath,
+  inspectScheduled = (path) => inspectScheduledCommand(path, { launch }),
+  checkLaunch = () => checkLaunchCommand(launch)
+} = {}) {
+  const runtime = await loadRuntime().catch(() => null);
+  const reminderNode = await readSchedulerNodePath().catch(() => null);
+  const launchCheck = await checkLaunch().catch((error) => ({ status: 'failed', command: launch.command, kind: launch.kind, detail: error.message }));
+  const recorded = runtime?.nodePath
+    ? await inspect(runtime.nodePath)
+    : { status: 'unknown' };
+  const reminder = reminderNode
+    ? await inspectScheduled(reminderNode)
+    : { status: 'unknown' };
+  // With the launcher, a gone or switched recorded node is not fatal: the
+  // launcher falls back to another Node 22+.
+  const launcherCovers = launch.kind === 'launcher' && launchCheck?.status === 'ok';
+  const recordedNote = launcherCovers && (recorded.status === 'missing' || recorded.status === 'stale')
+    ? `the launcher uses ${launchCheck.node || 'another Node'}; run \`logwork setup\` to record it`
+    : '';
+  const issues = [
+    formatLaunchCheckIssue(launchCheck),
+    launcherCovers ? '' : formatNodePathIssue('runtime', recorded),
+    formatNodePathIssue('reminder', reminder)
+  ].filter(Boolean);
+  return {
+    runtimeFile: runtimeInfoPath(),
+    launchCommand: [launch.command, ...launch.argsPrefix].join(' '),
+    launchStatus: launchCheck?.status || 'unknown',
+    launchNode: launchCheck?.node || '',
+    launchVersion: launchCheck?.version || '',
+    recordedNode: runtime?.nodePath || '',
+    recordedVersion: runtime?.nodeVersion || '',
+    recordedStatus: recorded.status,
+    recordedNote,
+    reminderNode: reminderNode || '',
+    reminderStatus: reminder.status,
+    issues
   };
 }
 
+// The `logwork` entry of each MCP client config (what `logwork mcp status`
+// shows). Read-only.
+export async function collectMcpClientCheck({
+  ctx = createMcpInstallContext()
+} = {}) {
+  const clients = await inspectMcpClients(ctx);
+  return clients.filter((client) => client.detected).map((client) => ({
+    label: client.label,
+    status: client.status,
+    reason: client.reason,
+    legacy: client.legacy,
+    localScopes: (client.localScopes || []).length
+  }));
+}
+
+function formatMcpClientCheck(client) {
+  const extra = [
+    client.reason,
+    client.legacy ? 'leftover logwork-helper entry' : '',
+    client.localScopes ? `${client.localScopes} stale local-scope entries` : ''
+  ].filter(Boolean).join('; ');
+  return `${client.label}: ${client.status}${extra ? ` (${extra})` : ''}`;
+}
+
 async function readPackageInfo({ readFileFn }) {
   try {
     const packagePath = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
@@ -202,7 +314,7 @@ async function safeCollect(label, fn) {
   }
 }
 
-export async function runMcpSmoke({ cwd = process.cwd(), timeoutMs = MCP_SMOKE_TIMEOUT_MS } = {}) {
+export async function runMcpSmoke({ timeoutMs = MCP_SMOKE_TIMEOUT_MS } = {}) {
   const client = new Client({
     name: 'logwork-diagnostics',
     version: '0.1.0'