logwork-cli 1.1.1 → 1.2.0

package/lib/apply-ledger.mjs

@@ -211,7 +211,7 @@ function createRecordId(date, random) {
 
 function cleanText(value, maxLength) {
   const text = String(value || '')
-    .replace(/Bearer\s+[A-Za-z0-9._~+\/-]+/gi, 'Bearer <redacted>')
+    .replace(/Bearer\s+[A-Za-z0-9._~+/-]+/gi, 'Bearer <redacted>')
     .replace(/(token|password|secret|otp)\s*[=:]\s*[^\s,;]+/gi, '$1=<redacted>')
     .trim();
   return text ? text.slice(0, maxLength) : '';

package/lib/batch-workflow.mjs

@@ -3,8 +3,10 @@ import {
   ApiError,
   fetchWorklogTasksForProject,
   getBookedProjectsForDate,
+  getLogworkDay,
   getProjects
 } from './api.mjs';
+import { isAuthRequiredError } from './auth-errors.mjs';
 import {
   listAvailableTaskNames,
   listSuggestedTaskNames,
@@ -24,6 +26,7 @@ export async function previewLogworkBatch({
   fetchProjects,
   fetchMembershipProjects,
   fetchWorklogTasks,
+  fetchDayEntries,
   typeOfWork,
   defaultWorklogTask
 }) {
@@ -72,9 +75,153 @@ export async function previewLogworkBatch({
     : enriched;
   // typeOfWork also changes what gets written, so it is folded into the
   // batchId the same way.
-  return typeOfWork
+  const typed = typeOfWork
     ? { ...output, typeOfWork, batchId: `${output.batchId}_${hash(`typeOfWork:${typeOfWork}`)}`, summary: `${output.summary}\n\nType of work for every entry: ${typeOfWork}` }
     : output;
+  return attachDuplicateWarnings(typed, {
+    fetchDayEntries: fetchDayEntries || createDayEntriesFetcher()
+  });
+}
+
+// Duplicate guard: an entry is a possible duplicate when RO already has an
+// entry on the same date with the same worklog task (id, else name), the same
+// hours and the same description (trimmed, whitespace collapsed, any case), or
+// when an earlier line of this batch is identical. Apply refuses those entries
+// unless allowDuplicates: true. A failed day read (other than auth) skips the
+// check for that date and says so; it never blocks the preview.
+export async function attachDuplicateWarnings(preview, { fetchDayEntries } = {}) {
+  const entries = preview.entries || [];
+  if (!entries.length || preview.errors?.length) {
+    return preview;
+  }
+
+  const dates = [...new Set(entries.map((entry) => entry.date).filter(Boolean))].sort();
+  const existingByDate = new Map();
+  const skipped = [];
+  for (const date of dates) {
+    try {
+      existingByDate.set(date, await fetchDayEntries(date));
+    } catch (error) {
+      if (isAuthRequiredError(error) || (error instanceof ApiError && error.status === 401)) {
+        throw error;
+      }
+      skipped.push({ date, error: String(error?.message || error) });
+    }
+  }
+
+  const seen = [];
+  const flagged = entries.map((entry) => {
+    const { possibleDuplicate: _previous, ...base } = entry;
+    const existing = (existingByDate.get(entry.date) || [])
+      .filter((candidate) => !candidate?.raw?.deleted_date && !candidate?.deletedDate)
+      .find((candidate) => isSameLogwork(entry, candidate));
+    const earlier = seen.find((candidate) => isSameLogwork(entry, candidate));
+    seen.push(entry);
+    if (existing) {
+      return {
+        ...base,
+        possibleDuplicate: {
+          source: 'ro',
+          logworkId: existing.id ?? null,
+          date: existing.date || entry.date,
+          hours: Number(existing.hours),
+          taskName: existingTaskName(existing),
+          worklogTaskId: existing.worklogTaskId ?? null,
+          description: existing.description || '',
+          status: existing.status || '',
+          projectName: existing.projectName || ''
+        }
+      };
+    }
+    if (earlier) {
+      return {
+        ...base,
+        possibleDuplicate: {
+          source: 'batch',
+          logworkId: null,
+          entryId: earlier.id,
+          date: earlier.date,
+          hours: earlier.hours,
+          taskName: earlier.taskName,
+          description: earlier.description || ''
+        }
+      };
+    }
+    return base;
+  });
+
+  const duplicateEntries = flagged.filter((entry) => entry.possibleDuplicate);
+  const duplicateCheck = {
+    status: skipped.length ? (skipped.length === dates.length ? 'skipped' : 'partial') : 'checked',
+    checkedDates: dates.filter((date) => existingByDate.has(date)),
+    ...(skipped.length ? { skippedDates: skipped } : {})
+  };
+  const summaryLines = [];
+  if (duplicateEntries.length) {
+    summaryLines.push(`Possible duplicates: ${duplicateEntries.length}. Apply requires allowDuplicates: true.`);
+    summaryLines.push(...duplicateEntries.map(formatDuplicateWarning));
+  }
+  for (const item of skipped) {
+    summaryLines.push(`Note: duplicate check skipped for ${item.date} (could not read RO entries: ${item.error}).`);
+  }
+
+  return {
+    ...preview,
+    entries: flagged,
+    unresolvedEntries: flagged.filter((entry) => entry.status === 'unresolved'),
+    unbookedEntries: flagged.filter((entry) => entry.status === 'resolved_unbooked'),
+    duplicateEntries,
+    duplicateCheck,
+    approvalSummary: {
+      ...preview.approvalSummary,
+      possibleDuplicates: duplicateEntries.length,
+      requiresAllowDuplicates: duplicateEntries.length > 0
+    },
+    summary: summaryLines.length ? `${preview.summary}\n${summaryLines.join('\n')}` : preview.summary
+  };
+}
+
+function formatDuplicateWarning(entry) {
+  const duplicate = entry.possibleDuplicate;
+  const line = `${entry.id}: +${entry.hours}h ${formatTaskAndDescription(entry)}`;
+  if (duplicate.source === 'batch') {
+    return `- WARNING possible duplicate ${line} repeats line ${duplicate.entryId} of this batch.`;
+  }
+  const status = duplicate.status ? `, ${duplicate.status}` : '';
+  const project = duplicate.projectName ? ` on ${duplicate.projectName}` : '';
+  return `- WARNING possible duplicate ${line} matches existing RO logwork ${duplicate.logworkId ?? '(no id)'}${project}${status}.`;
+}
+
+function isSameLogwork(entry, other) {
+  if (!other || (other.date && entry.date && other.date !== entry.date)) {
+    return false;
+  }
+  if (Math.abs(Number(entry.hours) - Number(other.hours)) > 1e-9) {
+    return false;
+  }
+  if (normalizeDuplicateText(entry.description) !== normalizeDuplicateText(other.description)) {
+    return false;
+  }
+  const entryTaskId = entry.worklogTaskId;
+  const otherTaskId = other.worklogTaskId;
+  if (hasId(entryTaskId) && hasId(otherTaskId)) {
+    return String(entryTaskId) === String(otherTaskId);
+  }
+  const entryTask = normalizeDuplicateText(entry.worklogTaskName || entry.taskName);
+  return Boolean(entryTask) && entryTask === normalizeDuplicateText(existingTaskName(other));
+}
+
+function existingTaskName(entry) {
+  const raw = entry?.raw || {};
+  return entry?.worklogTaskName || raw.worklog_task_name || raw.worklog_task?.name || raw.worklogTask?.name || entry?.taskName || '';
+}
+
+function normalizeDuplicateText(value) {
+  return String(value ?? '').trim().replace(/\s+/g, ' ').toLowerCase();
+}
+
+function hasId(value) {
+  return value !== undefined && value !== null && String(value).trim() !== '';
 }
 
 export const LOGWORK_LINE_FORMAT = '+<hours> <worklog task> | <description>';
@@ -313,9 +460,11 @@ export async function applyLogworkBatch({
   confirm,
   projectOverrides = {},
   allowUnbooked = false,
+  allowDuplicates = false,
   cwd = process.cwd(),
   fetchProjects,
   fetchMembershipProjects,
+  fetchDayEntries,
   submitEntry,
   verifyLogwork,
   recordLedger,
@@ -332,7 +481,8 @@ export async function applyLogworkBatch({
       projectOverrides,
       cwd,
       fetchProjects,
-      fetchMembershipProjects
+      fetchMembershipProjects,
+      fetchDayEntries
     });
 
   if (preview.errors?.length) {
@@ -351,6 +501,11 @@ export async function applyLogworkBatch({
     throw new Error(`Cannot apply ${unbookedEntries.length} unbooked entries without allowUnbooked: true. ${blocked}`);
   }
 
+  const duplicateEntries = preview.entries.filter((entry) => entry.possibleDuplicate);
+  if (duplicateEntries.length && allowDuplicates !== true) {
+    throw new Error(`Nothing was written. ${formatDuplicateBlock(duplicateEntries)} Apply requires allowDuplicates: true.`);
+  }
+
   const results = [];
   const taskCache = new Map();
   const entrySubmitter = submitEntry || createLogtimeSubmitter(taskCache);
@@ -474,6 +629,36 @@ function createBookedProjectsFetcher() {
   };
 }
 
+export function formatDuplicateBlock(entries) {
+  const list = entries.map((entry) => {
+    const duplicate = entry.possibleDuplicate || {};
+    const target = duplicate.source === 'batch'
+      ? `line ${duplicate.entryId}`
+      : `RO logwork ${duplicate.logworkId ?? '(no id)'}`;
+    return `${entry.id} (+${entry.hours}h ${entry.taskName}) matches ${target}`;
+  }).join('; ');
+  return `${entries.length} entr${entries.length === 1 ? 'y looks' : 'ies look'} already logged: ${list}.`;
+}
+
+// Existing RO entries for one date, from GET /logwork/day, with one forced
+// re-login on a 401.
+function createDayEntriesFetcher() {
+  const session = createResourceOptimiserSession();
+  return async (localDateISO) => {
+    const { token } = await session.get();
+    try {
+      return (await getLogworkDay(token, { date: localDateISO })).entries || [];
+    } catch (error) {
+      if (!(error instanceof ApiError) || error.status !== 401) {
+        throw error;
+      }
+
+      const refreshed = await session.get({ forceLogin: true });
+      return (await getLogworkDay(refreshed.token, { date: localDateISO })).entries || [];
+    }
+  };
+}
+
 function createMembershipProjectsFetcher() {
   const session = createResourceOptimiserSession();
   return async () => {

package/lib/commit-workflow.mjs

@@ -3,6 +3,9 @@ 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';
 
@@ -10,8 +13,11 @@ 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.
@@ -115,8 +121,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 +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)),
-      // 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 +413,9 @@ 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, expandHome(String(repo)))))];
@@ -360,14 +456,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 +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, remainingByProject: booking.remainingByProject } : {}),
+      ...(split ? { projectAllocation: split.allocation, unresolvedAllocation: split.unresolved } : {}),
       groups: groups.map((group, index) => ({
         hours: hours[index],
         task: group.task,
@@ -394,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
@@ -401,15 +512,32 @@ 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 ? 'no_commits' : (draftText ? 'draft' : 'no_hours'),
     range,
@@ -418,7 +546,9 @@ export async function draftLogworkFromCommits({
     ...(bookingsError ? { bookingsError } : {}),
     commitCount: commits.length,
     days,
-    draftText
+    draftText,
+    projectOverrides,
+    unmappedRepos
   };
   result.summary = formatCommitDraftSummary(result);
   return result;
@@ -446,18 +576,55 @@ 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 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;
 }

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 = {