logwork-cli 1.1.0 → 1.2.0

package/lib/commit-workflow.mjs

@@ -1,6 +1,11 @@
 import { spawn } from 'node:child_process';
+import { homedir } from 'node:os';
 import { resolve } from 'node:path';
+import { isAuthRequiredError } from './auth-errors.mjs';
 import { CONFIG } from './config.mjs';
+import { findRepoMapping, loadLocalConfig } from './logwork-config.mjs';
+import { projectIdentityKey, sameProjectIdentity } from './project-identity.mjs';
+import { resolveEntryProject } from './project-resolver.mjs';
 import { normalizeQueryRange, queryLogwork } from './query-workflow.mjs';
 import { addLocalDays, todayLocalDateISO } from './util.mjs';
 
@@ -8,13 +13,20 @@ import { addLocalDays, todayLocalDateISO } from './util.mjs';
 //   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
+//   -> 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.
 // Nothing is written anywhere; the agent shows the draft, the user edits and
 // approves it, then log_work previews and applies it as usual.
 
 const TICKET_RE = /\b[A-Z][A-Z0-9]+-\d+\b/g;
+// Prefixes that look like ticket keys but are standards or versions
+// ("UTF-8", "ISO-8601", "SHA-256", "CVE-2024-1234").
+const NOT_TICKET_PREFIXES = new Set(['UTF', 'ISO', 'SHA', 'RFC', 'HTTP', 'HTTPS', 'ES', 'ECMA', 'TLS', 'SSL', 'MD', 'AES', 'RSA', 'UTC', 'GMT', 'CVE', 'CWE', 'IPV', 'WCAG', 'PEP', 'JSR', 'ISBN', 'COVID', 'MP', 'H', 'X', 'IE', 'WIN', 'NODE', 'PHP', 'IOS']);
+const MAX_TICKETS_IN_DESCRIPTION = 4;
 const CONVENTIONAL_RE = /^(\w+)(?:\([^)]*\))?!?:\s*/;
 const FIELD = '\x1f';
 const RECORD = '\x1e';
@@ -109,38 +121,87 @@ 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 authorFilter = author || (await runGit(root, ['config', 'user.email']).catch(() => '')).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.`);
   }
-  const output = await runGit(root, [
+  // The period is matched on the author date in JS below. Git's --since and
+  // --until use the committer date (so rebased or amended commits would fall
+  // out of their real day) and --since stops the walk at the first older
+  // commit (clock skew). --since-as-filter (git 2.37+) only filters, and a day
+  // of slack covers time zones; older git falls back to a 31-day window.
+  const sinceDate = addLocalDays(from, -1);
+  const baseArgs = [
     'log',
-    // Every local and remote branch (work often sits on feature branches), but
-    // not refs/stash, whose "WIP on"/"index on" commits are not work items.
+    // Every local and remote branch (work often sits on feature branches) and
+    // HEAD (a detached HEAD mid-rebase), but not refs/stash, whose "WIP on" /
+    // "index on" commits are not work items.
     '--branches',
     '--remotes',
+    'HEAD',
     '--no-merges',
-    `--since=${from}T00:00:00`,
-    `--until=${to}T00:00:00`,
+    // Narrow by author in git (fixed string, so "." or "+" in an email is not
+    // a regex); the exact match happens in JS.
     `--author=${authorFilter}`,
+    '--fixed-strings',
     '--regexp-ignore-case',
     `--format=${RECORD}%H${FIELD}%at${FIELD}%an${FIELD}%ae${FIELD}%s${FIELD}%b${FIELD}`,
     '--numstat'
-  ]);
+  ];
+  let output;
+  try {
+    output = await runGit(root, [...baseArgs, `--since-as-filter=${sinceDate}T00:00:00`]);
+  } catch (error) {
+    if (!/since-as-filter|unrecognized argument|unknown option/i.test(error.message)) {
+      throw error;
+    }
+    output = await runGit(root, [...baseArgs, `--since=${addLocalDays(from, -31)}T00:00:00`]);
+  }
   const seen = new Set();
   const commits = parseGitLog(output)
+    .filter((commit) => matchesAuthor(commit, authorFilter))
     .filter((commit) => !seen.has(commit.hash) && seen.add(commit.hash))
     .map((commit) => ({ ...commit, repo: root, date: todayLocalDateISO(new Date(commit.timestamp * 1000)) }))
     .filter((commit) => commit.date >= from && commit.date < to);
   return { root, author: authorFilter, commits };
 }
 
+// Exact author match: an email filter must equal the author email, a name
+// filter must equal the author name (both case-insensitive). git --author is
+// a substring match, so "me@x.com" alone would also match "jime@x.com".
+export function matchesAuthor(commit, authorFilter) {
+  const filter = String(authorFilter || '').trim().toLowerCase();
+  if (!filter) {
+    return true;
+  }
+  const email = String(commit.authorEmail || '').toLowerCase();
+  const name = String(commit.authorName || '').toLowerCase();
+  const bracketed = filter.match(/<([^>]+)>/);
+  if (bracketed) {
+    return email === bracketed[1].trim();
+  }
+  return filter.includes('@') ? email === filter : name === filter;
+}
+
+export function extractTickets(text = '') {
+  return [...new Set((String(text).match(TICKET_RE) || [])
+    .filter((key) => !NOT_TICKET_PREFIXES.has(key.slice(0, key.lastIndexOf('-')))))];
+}
+
 export function groupCommits(commits = []) {
   const groups = new Map();
   for (const commit of [...commits].sort((a, b) => a.timestamp - b.timestamp)) {
-    const tickets = [...new Set(`${commit.subject}\n${commit.body}`.match(TICKET_RE) || [])];
+    const tickets = extractTickets(`${commit.subject}\n${commit.body}`);
     const kind = classifyCommit(commit.subject, commit.body);
     const key = [commit.repo, tickets[0] || '', kind].join('|');
     const group = groups.get(key) || {
@@ -172,9 +233,14 @@ export function groupCommits(commits = []) {
 }
 
 export function buildDescription(group) {
-  const ticketSuffix = group.tickets.length ? ` (${group.tickets.join(', ')})` : '';
-  const room = MAX_DESCRIPTION_LENGTH - ticketSuffix.length;
-  const subjects = group.subjects.map((subject) => subject.replace(TICKET_RE, '').replace(/\s*[[(]\s*[)\]]\s*/g, ' ').replace(/\s+/g, ' ').trim()).filter(Boolean);
+  const shown = group.tickets.slice(0, MAX_TICKETS_IN_DESCRIPTION);
+  const more = group.tickets.length - shown.length;
+  const ticketSuffix = shown.length ? ` (${shown.join(', ')}${more > 0 ? ` +${more} more` : ''})` : '';
+  const room = Math.max(40, MAX_DESCRIPTION_LENGTH - ticketSuffix.length);
+  const ticketSet = new Set(group.tickets);
+  const subjects = group.subjects
+    .map((subject) => subject.replace(TICKET_RE, (key) => (ticketSet.has(key) ? '' : key)).replace(/\s*[[(]\s*[)\]]\s*/g, ' ').replace(/\s+/g, ' ').trim())
+    .filter(Boolean);
   let text = '';
   for (const subject of subjects) {
     const next = text ? `${text}; ${subject}` : subject;
@@ -233,23 +299,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))
+      remainingHours: roundHours(remaining),
+      projects,
+      remainingByProject: projects
+        .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,
@@ -259,18 +413,29 @@ export async function draftLogworkFromCommits({
   useBookings = true,
   cwd = process.cwd(),
   runGit = runGitCommand,
-  queryRo = queryLogwork
+  queryRo = queryLogwork,
+  loadConfig = loadLocalConfig,
+  platform = process.platform
 } = {}) {
   const range = from || to ? normalizeQueryRange({ from, to }) : normalizeQueryRange({ period });
-  const repoPaths = [...new Set((repos?.length ? repos : [cwd]).map((repo) => resolve(cwd, String(repo))))];
+  const repoPaths = [...new Set((repos?.length ? repos : [cwd]).map((repo) => resolve(cwd, expandHome(String(repo)))))];
 
   const repoResults = [];
   const commits = [];
+  const seenRoots = new Set();
+  // A commit counts once even when two paths reach it (a subfolder of the same
+  // repo, or a git worktree of it).
+  const seenHashes = new Set();
   for (const repo of repoPaths) {
     try {
       const result = await readRepoCommits({ repo, from: range.from, to: range.to, author, runGit });
-      repoResults.push({ path: result.root, author: result.author, commitCount: result.commits.length });
-      commits.push(...result.commits);
+      if (seenRoots.has(result.root)) {
+        continue;
+      }
+      seenRoots.add(result.root);
+      const fresh = result.commits.filter((commit) => !seenHashes.has(commit.hash) && seenHashes.add(commit.hash));
+      repoResults.push({ path: result.root, author: result.author, commitCount: fresh.length });
+      commits.push(...fresh);
     } catch (error) {
       repoResults.push({ path: repo, error: error.message, commitCount: 0 });
     }
@@ -282,18 +447,29 @@ export async function draftLogworkFromCommits({
     try {
       bookings = remainingHoursByDay(await queryRo({ from: range.from, to: range.to, includeEntries: false, cwd }));
     } catch (error) {
+      // A missing or expired RO login must reach the agent as authRequired;
+      // falling back to an 8h day would hide hours that are already logged.
+      if (isAuthRequiredError(error)) {
+        throw error;
+      }
       bookingsError = error.message;
     }
   }
 
+  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) {
@@ -307,12 +483,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 } : {}),
+      ...(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,
@@ -320,6 +503,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
@@ -327,24 +512,43 @@ 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))];
+
   const result = {
-    status: commits.length ? 'draft' : 'no_commits',
+    status: !commits.length ? 'no_commits' : (draftText ? 'draft' : 'no_hours'),
     range,
     repos: repoResults,
     bookings: useBookings ? (bookings ? 'ro' : 'unavailable') : 'skipped',
     ...(bookingsError ? { bookingsError } : {}),
     commitCount: commits.length,
     days,
-    draftText
+    draftText,
+    projectOverrides,
+    unmappedRepos
   };
   result.summary = formatCommitDraftSummary(result);
   return result;
@@ -371,16 +575,60 @@ export function formatCommitDraftSummary(result) {
       standard_day: `standard day ${day.targetHours}h`
     }[day.hoursSource];
     lines.push('', `${formatDayHeading(day.date)} - ${source}`);
+    if (day.remainingByProject?.length) {
+      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 some lines from: ${result.unmappedRepos.join(', ')}. Ask the user which RO project each repo belongs to and offer map_project with repos so later drafts know it.`);
   }
   return lines.join('\n');
 }
 
+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;
+}
+
 function runGitCommand(cwd, args) {
   return new Promise((resolveValue, reject) => {
     const child = spawn('git', ['-C', cwd, ...args], { stdio: ['ignore', 'pipe', 'pipe'] });

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,9 @@ 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 { formatNodePathIssue, inspectNodePath, 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 +36,7 @@ export async function generateDiagnosticsReport({
   commandFinder = findCommandOnPath,
   authStatusFn = getStoredAuthStatus,
   mcpSmokeFn = runMcpSmoke,
+  nodeRuntimeFn = collectNodeRuntimeCheck,
   readFileFn = readFile,
   statFn = stat,
   writeFileFn = writeFile,
@@ -47,6 +49,8 @@ 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 nodeIssues = Array.isArray(nodeRuntime?.issues) ? nodeRuntime.issues : [];
   const authDebug = await readSanitizedAuthDebug({ readFileFn });
 
   sections.push(formatSection('logwork-cli Diagnostics', [
@@ -64,6 +68,17 @@ export async function generateDiagnosticsReport({
     `home: ${homedir()}`
   ]));
 
+  sections.push(formatSection('Node Path', nodeRuntime?.ok === false
+    ? formatObjectLines(nodeRuntime)
+    : [
+      `runtimeFile: ${nodeRuntime.runtimeFile}`,
+      `recordedNode: ${nodeRuntime.recordedNode || 'none (run logwork setup)'}${nodeRuntime.recordedVersion ? ` (${nodeRuntime.recordedVersion})` : ''}`,
+      `recordedNodeStatus: ${nodeRuntime.recordedStatus}`,
+      `reminderNode: ${nodeRuntime.reminderNode || 'none (no reminder schedule)'}`,
+      `reminderNodeStatus: ${nodeRuntime.reminderStatus}`,
+      ...(nodeIssues.length ? nodeIssues.map((issue) => `warning: ${issue}`) : ['warnings: none'])
+    ]));
+
   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,7 +93,41 @@ 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)
+  };
+}
+
+// Compares the node recorded by `logwork setup` (runtime.json) and the node in
+// the installed reminder schedule with the node running now. Read-only.
+export async function collectNodeRuntimeCheck({
+  loadRuntime = loadRuntimeInfo,
+  readSchedulerNodePath = readReminderSchedulerNodePath,
+  inspect = inspectNodePath
+} = {}) {
+  const runtime = await loadRuntime().catch(() => null);
+  const reminderNode = await readSchedulerNodePath().catch(() => null);
+  const recorded = runtime?.nodePath
+    ? await inspect(runtime.nodePath)
+    : { status: 'unknown' };
+  const reminder = reminderNode
+    ? await inspect(reminderNode)
+    : { status: 'unknown' };
+  const issues = [
+    formatNodePathIssue('runtime', recorded),
+    formatNodePathIssue('reminder', reminder)
+  ].filter(Boolean);
+  return {
+    runtimeFile: runtimeInfoPath(),
+    recordedNode: runtime?.nodePath || '',
+    recordedVersion: runtime?.nodeVersion || '',
+    recordedStatus: recorded.status,
+    reminderNode: reminderNode || '',
+    reminderStatus: reminder.status,
+    issues
   };
 }
 
@@ -202,7 +251,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'

package/lib/jira-api.mjs

@@ -1,4 +1,4 @@
-import { CONFIG } from './config.mjs';
+import { CONFIG, isDryRun } from './config.mjs';
 import { ApiError } from './api.mjs';
 import { fetchWithPolicy, redactedExcerpt } from './http.mjs';
 import { safeJsonParse } from './util.mjs';
@@ -15,6 +15,11 @@ export async function jiraApiFetch(token, path, {
 } = {}) {
   assertJiraToken(token);
   const url = buildJiraUrl(baseUrl, path);
+  // Every Jira write goes through here, so this one gate covers worklog create
+  // and any write added later. The result never carries the token or headers.
+  if (!isIdempotentMethod(method) && isDryRun()) {
+    return createJiraDryRunRequest(method, path, body);
+  }
   const response = await fetchWithPolicy(url.toString(), {
     fetchImpl,
     timeoutMs,
@@ -123,12 +128,29 @@ export async function addJiraIssueWorklog(token, issueKey, worklog, options = {}
   assertIssueKey(issueKey);
   const qs = new URLSearchParams({ adjustEstimate: 'leave' });
   const path = `/rest/api/2/issue/${encodeURIComponent(issueKey)}/worklog?${qs}`;
-  return normalizeJiraWorklog(await jiraApiFetch(token, path, {
+  const data = await jiraApiFetch(token, path, {
     ...options,
     method: 'POST',
     retries: 0,
     body: worklog
-  }));
+  });
+  return isJiraDryRunResult(data) ? data : normalizeJiraWorklog(data);
+}
+
+export function isJiraDryRunResult(value) {
+  return value?.dryRun === true;
+}
+
+function createJiraDryRunRequest(method, path, body) {
+  const request = {
+    dryRun: true,
+    method: String(method).toUpperCase(),
+    path: String(path)
+  };
+  if (body !== undefined) {
+    request.body = structuredClone(body);
+  }
+  return request;
 }
 
 export function normalizeJiraIssue(issue = {}) {