logwork-cli 1.1.1 → 1.3.0

package/lib/mcp-server.mjs

@@ -1,12 +1,13 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
-import { ApiError } from './api.mjs';
+import { ApiError } from './ro-api-http.mjs';
 import { queryApplyLedger } from './apply-ledger.mjs';
 import { readLogworkSkill } from './agent-skill.mjs';
 import { draftLogworkFromCommits } from './commit-workflow.mjs';
 import {
   applyLogworkBatch,
+  formatDuplicateBlock,
   formatToolResponse,
   listWorklogTasks,
   previewLogworkBatch
@@ -64,6 +65,7 @@ export const SERVER_INSTRUCTIONS = `logwork logs work hours to Resource Optimise
 
 Safety rules:
 - Writes are two calls to the same tool. Call it without confirm to get a preview (batchId or previewId plus a summary), show the summary to the user, wait for explicit approval, then call the same tool again with only that id and confirm: true. Never set confirm: true without approval.
+- log_work previews flag possibleDuplicate entries (same date, worklog task, hours and description as an existing RO entry, or a repeated line). Show the warning; apply refuses them unless the user confirms it is new work and you call again with the same batchId and allowDuplicates: true. Never pass allowDuplicates or allowUnbooked without asking.
 - Never ask for or pass passwords, OTP codes, or tokens. If a tool returns authRequired, call login (target "ro" or "jira") and ask the user to finish login in their terminal.
 
 Logwork text format (log_work and log_jira_work):
@@ -75,7 +77,7 @@ Logwork text format (log_work and log_jira_work):
 - Lines without "|" are accepted only when the text is itself a catalog task name (no description is written), or when defaultWorklogTask is passed (the text then becomes the description).
 - Jira needs exactly one issue key such as SCB-213 in the line.
 
-Recommended RO flow: get_logwork (what is booked/logged) -> draft_from_commits (the user's git commits as draft lines) -> list_tasks(projectId) -> log_work(text) -> user approval -> log_work(batchId, confirm: true).
+Recommended RO flow: get_logwork (what is booked/logged) -> draft_from_commits (the user's git commits as draft lines plus projectOverrides) -> list_tasks(projectId) -> log_work(text, projectOverrides) -> user approval -> log_work(batchId, confirm: true).
 Base every line on the user's commits or on what the user tells you; never invent work. The log_from_commits prompt has the full procedure.
 Fixing existing RO entries (logworkId from get_logwork): submitted/approved entries -> edit_entry (hours, worklog task, type of work, description; apply replaces the entry with a new id, approved immediately); rejected entries -> resubmit_entry; removing an entry -> delete_entry.
 If a preview entry is unresolved: worklog_task_required / task_not_found means fix the worklog task (see availableTaskNames); project reasons mean ask the user to pick a project (projectOverrides) or save a mapping with map_project.`;
@@ -133,7 +135,7 @@ server.registerTool('list_tasks', {
 
 server.registerTool('draft_from_commits', {
   title: 'Draft logwork from git commits',
-  description: 'Read-only: read the user\'s own git commits (all branches, git user.email) in one or more repos for a period, group them per day by repo + ticket + kind of work, suggest an RO worklog task per group (feat -> Feature Development, fix -> Bug Fix, refactor/review -> Code Review & Refactoring, test -> Testing Activities, ci/build/release -> Deployment & Release, docs -> Requirements & Design), and split each day\'s remaining RO hours (booked - logged) across the groups. Returns draftText in the log_work line format. Review it with the user, check task names with list_tasks, then pass it to log_work.',
+  description: 'Read-only: read the user\'s own git commits (all branches, git user.email) in one or more repos for a period, group them per day by repo + ticket + kind of work, suggest an RO worklog task per group (feat -> Feature Development, fix -> Bug Fix, refactor/review -> Code Review & Refactoring, test -> Testing Activities, ci/build/release -> Deployment & Release, docs -> Requirements & Design), and resolve each group\'s RO project (a map_project mapping whose repos holds the repo, else ticket/keyword mappings and that day\'s bookings), and split each project\'s remaining RO hours (booked - logged) across its groups; groups without a project share the room of booked projects no group claimed. Returns draftText in the log_work line format plus projectOverrides (preview entry id -> projectMemberId) for every line with a project. Review it with the user, check task names with list_tasks, then pass draftText and projectOverrides unchanged to log_work. unmappedRepos lists repos whose lines got no project; repoSuggestions maps each of them to up to 5 ranked projects ({ projectName, projectMemberId, projectId, score, reasons }) from ticket history, repo/remote name and single booked project, and projectCandidates lists every member project. For each unmapped repo ask the user one short question naming the top suggestion ("Is <repo> part of <projectName>?"), then call map_project with projectName (or projectMemberId) and repos (confirm: true after approval), and run draft_from_commits again. Never ask the user for ids.',
   annotations: READ_ONLY,
   inputSchema: {
     period: z.enum(PERIOD_VALUES).optional().describe('Preset period. Defaults to today.'),
@@ -147,27 +149,29 @@ server.registerTool('draft_from_commits', {
 
 server.registerTool('log_work', {
   title: 'Log work to Resource Optimiser',
-  description: `Resource Optimiser only: create new RO entries (worklog task + hours + date + type of work + description) from a weekly logwork block. ${TWO_STEP} The preview resolves the project (bookings, mappings, ticket prefixes) and worklog task per line; unresolved lines block apply. Use log_jira_work for Jira.`,
+  description: `Resource Optimiser only: create new RO entries (worklog task + hours + date + type of work + description) from a weekly logwork block. ${TWO_STEP} The preview resolves the project (bookings, mappings, ticket prefixes) and worklog task per line; unresolved lines block apply. It also reads each date's RO entries and flags possibleDuplicate lines (same date, worklog task, hours and description, or a repeated line); apply refuses them unless allowDuplicates: true. Use log_jira_work for Jira.`,
   annotations: WRITE,
   inputSchema: {
     text: z.string().min(1).optional().describe(ENTRY_TEXT_DESCRIPTION),
-    projectOverrides: z.record(z.string(), z.union([z.string(), z.number()])).optional().describe('Preview call only. Map preview entry id (e.g. "2026-06-01-01") to the projectMemberId the user chose for an unresolved entry.'),
+    projectOverrides: z.record(z.string(), z.union([z.string(), z.number()])).optional().describe('Preview call only. Map preview entry id (e.g. "2026-06-01-01") to the projectMemberId the user chose for an unresolved entry, or pass the projectOverrides returned by draft_from_commits with its draftText unchanged.'),
     defaultWorklogTask: z.string().min(1).optional().describe('Preview call only. Worklog task name (or "#<id>") for lines without "|" whose text is not a catalog task; that text becomes the description. Example: "Feature Development".'),
     typeOfWork: TYPE_OF_WORK_SCHEMA.optional().describe('Preview call only. Override type_of_work for every entry. When omitted, each entry takes its worklog task type, else "other".'),
     batchId: BATCH_ID_SCHEMA,
     allowUnbooked: z.boolean().optional().describe('Apply call only. Allow entries resolved to a project membership without a booking on that date.'),
+    allowDuplicates: z.boolean().optional().describe('Apply call only. Allow entries the preview flagged as possibleDuplicate (same date, worklog task, hours and description as an existing RO entry or an earlier line). Pass true only after the user confirmed they are new work.'),
     confirm: CONFIRM_SCHEMA
   }
-}, withAuthRequiredHandling(async ({ text, projectOverrides, defaultWorklogTask, typeOfWork, batchId, allowUnbooked = false, confirm }) => {
+}, withAuthRequiredHandling(async ({ text, projectOverrides, defaultWorklogTask, typeOfWork, batchId, allowUnbooked = false, allowDuplicates = false, confirm }) => {
   prunePreviewCache(previews);
   if (confirm === true) {
     assertApplyOnly('log_work', { text, projectOverrides, defaultWorklogTask, typeOfWork });
-    // Check allowUnbooked before the preview is consumed, so the agent can
-    // retry the same batchId with allowUnbooked: true.
+    // Check allowUnbooked and allowDuplicates before the preview is consumed,
+    // so the agent can retry the same batchId with the flag set.
     const pending = resolveApprovedBatch({ cache: previews, batchId });
     assertUnbookedAllowed(pending, allowUnbooked);
+    assertDuplicatesAllowed(pending, allowDuplicates);
     const approvedBatch = consumeApprovedBatch({ cache: previews, batchId });
-    return formatToolResponse(await applyLogworkBatch({ batch: approvedBatch, confirm, allowUnbooked }));
+    return formatToolResponse(await applyLogworkBatch({ batch: approvedBatch, confirm, allowUnbooked, allowDuplicates }));
   }
   requirePreviewInput('log_work', { text });
   const preview = await previewLogworkBatch({ text, projectOverrides: projectOverrides || {}, typeOfWork, defaultWorklogTask });
@@ -261,8 +265,7 @@ server.registerTool('log_jira_work', {
   prunePreviewCache(jiraPreviews);
   if (confirm === true) {
     assertApplyOnly('log_jira_work', { text });
-    const approvedBatch = consumeApprovedJiraBatch({ cache: jiraPreviews, batchId });
-    return formatToolResponse(await applyJiraWorklogBatch({ batch: approvedBatch, confirm }));
+    return applyCachedJiraWork({ cache: jiraPreviews, batchId, confirm });
   }
   requirePreviewInput('log_jira_work', { text });
   const preview = await previewJiraWorklogBatch({ text });
@@ -308,18 +311,19 @@ server.registerTool('get_history', {
 
 server.registerTool('map_project', {
   title: 'Save a project mapping',
-  description: 'Save a local ticket-prefix/keyword -> RO project mapping so future log_work previews resolve the project automatically. Writes .logwork.json; requires confirm: true after the user approved the mapping.',
+  description: 'Save a local ticket-prefix/keyword/git repo -> RO project mapping so future log_work previews resolve the project automatically and draft_from_commits allocates a repo\'s commits to its project. Pass tickets, repos, or both. Writes .logwork.json; requires confirm: true after the user approved the mapping.',
   annotations: { ...LOCAL_WRITE, idempotentHint: true },
   inputSchema: {
     projectMemberId: z.union([z.string(), z.number()]).optional().describe('RO projectMemberId from list_projects or preview setupSuggestions.'),
     projectName: z.string().optional().describe('Project name to match against the user\'s memberships when projectMemberId is not given.'),
-    tickets: z.array(z.string()).min(1).describe('Ticket prefixes to map, for example ["SCB"].'),
+    tickets: z.array(z.string()).optional().describe('Ticket prefixes to map, for example ["SCB"]. At least one ticket prefix or repo is required.'),
     keywords: z.array(z.string()).optional().describe('Optional task keywords to map to the project.'),
+    repos: z.array(z.string().min(1)).max(20).optional().describe('Absolute paths of git repos whose commits belong to this project (a subfolder is stored as its repo root). draft_from_commits uses them to pick the project per commit.'),
     scope: z.enum(['user', 'project']).optional().describe('user (default): ~/.logwork-cli/.logwork.json for this machine. project: .logwork.json in the current repo.'),
     confirm: z.boolean().describe('Must be true, and only after explicit user approval.')
   }
-}, withAuthRequiredHandling(async ({ projectMemberId, projectName, tickets, keywords = [], scope = 'user', confirm }) => {
-  const result = await upsertProjectMapping({ projectMemberId, projectName, tickets, keywords, scope, confirm });
+}, withAuthRequiredHandling(async ({ projectMemberId, projectName, tickets = [], keywords = [], repos = [], scope = 'user', confirm }) => {
+  const result = await upsertProjectMapping({ projectMemberId, projectName, tickets, keywords, repos, scope, confirm });
   return formatToolResponse(result);
 }));
 
@@ -344,15 +348,19 @@ server.registerTool('login', {
 
 server.registerTool('reminder', {
   title: 'Logwork reminder',
-  description: 'The native macOS/Windows weekday logwork reminder. action "status" is read-only. "enable", "disable" and "test" (shows a sample notification) change the OS scheduler or display a notification and require confirm: true after explicit user approval. No credentials are stored in the schedule.',
+  description: 'The native macOS/Windows weekday logwork reminder. action "status" is read-only. "enable", "disable" and "test" (shows a sample notification) change the OS scheduler or display a notification and require confirm: true after explicit user approval. When RO hours are missing, the notification also counts today\'s commits in the configured repos. status warns when the command in the schedule (the logwork launcher, or node.exe on Windows) is missing or outdated. No credentials are stored in the schedule.',
   annotations: LOCAL_WRITE,
   inputSchema: {
     action: z.enum(['status', 'enable', 'disable', 'test']).describe('status: show config and scheduler state. enable/disable: install or remove the schedule. test: send a sample notification.'),
     time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/).optional().describe('enable only. Local time in 24-hour HH:mm. Defaults to 17:00.'),
     target: z.enum(['ro', 'jira', 'both']).optional().describe('enable/test only. What to check. Defaults to both (enable) or the configured target (test).'),
+    repos: z.array(z.string().min(1)).max(20).optional().describe('enable only. Absolute paths of git repos whose commits today the reminder counts when RO hours are missing. Replaces the saved list; [] clears it; omit to keep it.'),
     confirm: z.boolean().optional().describe('Required (true) for enable, disable and test, after explicit user approval.')
   }
-}, async ({ action, time, target, confirm }) => {
+}, async ({ action, time, target, repos, confirm }) => {
+  if (action !== 'enable' && repos !== undefined) {
+    throw new Error('repos is only valid when enabling the reminder.');
+  }
   if (action === 'status') {
     return formatToolResponse(await getLogworkReminderStatus());
   }
@@ -366,7 +374,7 @@ server.registerTool('reminder', {
     throw new Error('target is not valid when disabling the reminder.');
   }
   if (action === 'enable') {
-    return formatToolResponse(await enableLogworkReminder({ time, target, confirm }));
+    return formatToolResponse(await enableLogworkReminder({ time, target, repos, confirm }));
   }
   if (action === 'disable') {
     return formatToolResponse(await disableLogworkReminder({ confirm }));
@@ -550,7 +558,14 @@ export function resolveApprovedBatch({
   return clonePreview(cached.preview);
 }
 
-function assertUnbookedAllowed(batch, allowUnbooked) {
+export function assertDuplicatesAllowed(batch, allowDuplicates) {
+  const duplicates = (batch?.entries || []).filter((entry) => entry.possibleDuplicate);
+  if (duplicates.length && allowDuplicates !== true) {
+    throw new Error(`Nothing was written. ${formatDuplicateBlock(duplicates)} Ask the user whether this is new work, then call log_work again with the same batchId, confirm: true and allowDuplicates: true.`);
+  }
+}
+
+export function assertUnbookedAllowed(batch, allowUnbooked) {
   const unbooked = (batch?.entries || []).filter((entry) => entry.requiresAllowUnbooked);
   if (unbooked.length && allowUnbooked !== true) {
     throw new Error(`Nothing was written. ${unbooked.length} entr${unbooked.length === 1 ? 'y has' : 'ies have'} no booking on that date (${unbooked.map((entry) => entry.id).join(', ')}). Ask the user, then call log_work again with the same batchId, confirm: true and allowUnbooked: true.`);
@@ -573,6 +588,19 @@ export function consumeApprovedBatch({
   return approvedBatch;
 }
 
+// The log_jira_work apply call. With LOGWORK_DRY_RUN=1 the apply sends no
+// worklog and the response summary starts with "DRY RUN".
+export async function applyCachedJiraWork({
+  cache,
+  batchId,
+  confirm,
+  applyOptions = {},
+  now = Date.now()
+}) {
+  const approvedBatch = consumeApprovedJiraBatch({ cache, batchId, now });
+  return formatToolResponse(await applyJiraWorklogBatch({ ...applyOptions, batch: approvedBatch, confirm }));
+}
+
 export function resolveApprovedJiraBatch({
   cache,
   batchId,
@@ -684,7 +712,10 @@ export function createPreviewFingerprint(preview = {}) {
       confidence: numberOrNull(entry?.confidence),
       matchedProject: projectFingerprint(entry?.matchedProject),
       booked: booleanOrNull(entry?.booked),
-      requiresAllowUnbooked: booleanOrNull(entry?.requiresAllowUnbooked)
+      requiresAllowUnbooked: booleanOrNull(entry?.requiresAllowUnbooked),
+      possibleDuplicate: entry?.possibleDuplicate
+        ? textOrNull(entry.possibleDuplicate.logworkId ?? entry.possibleDuplicate.entryId)
+        : null
     }))
   });
 }

package/lib/node-runtime.mjs

@@ -0,0 +1,155 @@
+import { promises as fs } from 'node:fs';
+import { basename } from 'node:path';
+import { atomicWriteFile } from './atomic-file.mjs';
+import { LAUNCHER_FILE_NAME, resolveLaunchCommand } from './launcher.mjs';
+import { runtimeInfoPath } from './paths.mjs';
+
+// `logwork setup` records the node it ran with here. On macOS/Linux the
+// generated launcher (lib/launcher.mjs) tries that node first and falls back
+// to another Node 22+, so IDE configs and the reminder survive upgrades. On
+// Windows the configs and the task store a node.exe path, which `logwork
+// doctor` and `logwork reminder status` compare with this record.
+
+export async function writeRuntimeInfo({
+  path = runtimeInfoPath(),
+  nodePath = process.execPath,
+  nodeVersion = process.version,
+  version = null,
+  now = () => new Date(),
+  writeFile = atomicWriteFile
+} = {}) {
+  const info = {
+    nodePath: String(nodePath || ''),
+    nodeVersion: String(nodeVersion || ''),
+    installedAt: now().toISOString(),
+    version: version ? String(version) : null
+  };
+  await writeFile(path, `${JSON.stringify(info, null, 2)}\n`);
+  return info;
+}
+
+export async function loadRuntimeInfo({
+  path = runtimeInfoPath(),
+  readFile = fs.readFile
+} = {}) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(path, 'utf8'));
+  } catch (error) {
+    if (error.code === 'ENOENT' || error instanceof SyntaxError) {
+      return null;
+    }
+    throw error;
+  }
+  if (!parsed || typeof parsed !== 'object' || typeof parsed.nodePath !== 'string' || !parsed.nodePath) {
+    return null;
+  }
+  return {
+    nodePath: parsed.nodePath,
+    nodeVersion: typeof parsed.nodeVersion === 'string' ? parsed.nodeVersion : '',
+    installedAt: typeof parsed.installedAt === 'string' ? parsed.installedAt : '',
+    version: typeof parsed.version === 'string' ? parsed.version : null
+  };
+}
+
+// ok: the recorded node is the current one (same file after symlinks).
+// missing: the recorded node no longer exists.
+// stale: it exists but differs from the current, working node.
+export async function inspectNodePath(recordedPath, {
+  currentPath = process.execPath,
+  platform = process.platform,
+  exists = pathExists,
+  realpath = fs.realpath
+} = {}) {
+  const recorded = String(recordedPath || '');
+  if (!recorded) {
+    return { status: 'unknown', recordedPath: '', currentPath };
+  }
+  if (!await exists(recorded)) {
+    return { status: 'missing', recordedPath: recorded, currentPath };
+  }
+  const [left, right] = await Promise.all([
+    realpath(recorded).catch(() => recorded),
+    realpath(currentPath).catch(() => currentPath)
+  ]);
+  const same = platform === 'win32'
+    ? String(left).toLowerCase() === String(right).toLowerCase()
+    : left === right;
+  if (same) {
+    return { status: 'ok', recordedPath: recorded, currentPath };
+  }
+  if (!await exists(currentPath)) {
+    // Not stale: there is no working node to switch to.
+    return { status: 'differs', recordedPath: recorded, currentPath };
+  }
+  return { status: 'stale', recordedPath: recorded, currentPath };
+}
+
+// Compares the command an installed OS schedule runs with the current launch
+// command. Statuses:
+// ok: it runs the current launch command (and that command exists).
+// missing: the command (launcher or node) no longer exists.
+// legacy: macOS/Linux schedule from an older install that runs a raw Node
+//   path instead of the launcher.
+// stale: it runs another launcher or another node.
+export async function inspectScheduledCommand(commandPath, {
+  launch = resolveLaunchCommand(),
+  platform = process.platform,
+  exists = pathExists,
+  inspect = inspectNodePath
+} = {}) {
+  const recorded = String(commandPath || '');
+  const currentPath = launch.command;
+  if (!recorded) {
+    return { status: 'unknown', recordedPath: '', currentPath };
+  }
+  const same = platform === 'win32'
+    ? recorded.toLowerCase() === String(currentPath).toLowerCase()
+    : recorded === currentPath;
+  if (same) {
+    return { status: await exists(recorded) ? 'ok' : 'missing', recordedPath: recorded, currentPath, kind: launch.kind };
+  }
+  if (launch.kind === 'launcher') {
+    if (basename(recorded) === LAUNCHER_FILE_NAME) {
+      return { status: await exists(recorded) ? 'stale' : 'missing', recordedPath: recorded, currentPath, kind: 'launcher' };
+    }
+    return { status: await exists(recorded) ? 'legacy' : 'missing', recordedPath: recorded, currentPath, kind: 'node' };
+  }
+  const checked = await inspect(recorded, { currentPath, platform });
+  return { ...checked, currentPath, kind: 'node' };
+}
+
+// source "runtime": the node recorded by `logwork setup` (Windows MCP configs
+// use it). source "reminder": the command in the installed OS schedule.
+export function formatNodePathIssue(source, inspection) {
+  const { status, recordedPath, currentPath, kind } = inspection || {};
+  if (source === 'reminder') {
+    const what = kind === 'launcher' ? 'the logwork launcher at' : 'Node at';
+    if (status === 'missing') {
+      return `Reminder: the OS schedule runs ${what} ${recordedPath}, which no longer exists, so the reminder cannot run. Fix: run \`logwork reminder enable\` (or \`logwork setup\`) to re-register it.`;
+    }
+    if (status === 'legacy') {
+      return `Reminder: the OS schedule runs Node at ${recordedPath} directly instead of the logwork launcher, so a Node upgrade will break it. Fix: re-run \`logwork setup\` (or \`logwork reminder enable\`).`;
+    }
+    if (status === 'stale') {
+      return `Reminder: the OS schedule runs ${what} ${recordedPath}, but the current command is ${currentPath}. Fix: run \`logwork reminder enable\` (or \`logwork setup\`) to re-register it.`;
+    }
+    return '';
+  }
+  if (status === 'missing') {
+    return `Runtime: \`logwork setup\` recorded Node at ${recordedPath}, which no longer exists, so IDE MCP configs that use it cannot start. Fix: run \`logwork setup\`; it updates the MCP configs it can edit.`;
+  }
+  if (status === 'stale') {
+    return `Runtime: \`logwork setup\` recorded Node at ${recordedPath}, but the current Node is ${currentPath}. Fix: if you switched Node on purpose, run \`logwork setup\`; it updates the MCP configs it can edit.`;
+  }
+  return '';
+}
+
+async function pathExists(path) {
+  try {
+    await fs.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/lib/paths.mjs

@@ -9,6 +9,7 @@ export const APPLY_LEDGER_FILE_NAME = 'apply-ledger.json';
 export const UPDATE_STATE_FILE_NAME = 'update-state.json';
 export const REMINDER_CONFIG_FILE_NAME = 'reminder.json';
 export const REMINDER_STATE_FILE_NAME = 'reminder-state.json';
+export const RUNTIME_INFO_FILE_NAME = 'runtime.json';
 
 // Names used before the package was renamed from logwork-helper to logwork-cli.
 // lib/legacy-migration.mjs copies state from these locations on first run.
@@ -51,6 +52,12 @@ export function reminderStatePath() {
   return resolve(helperHome(), REMINDER_STATE_FILE_NAME);
 }
 
+// Written by `logwork setup`: the node binary and version the installed
+// runtime, MCP configs and reminder were set up with.
+export function runtimeInfoPath() {
+  return resolve(helperHome(), RUNTIME_INFO_FILE_NAME);
+}
+
 export function legacyUserConfigPath() {
   // A custom home (tests, separate profiles) keeps its state isolated from
   // the real ~/.logwork-helper.json.

package/lib/project-mapping-workflow.mjs

@@ -1,10 +1,12 @@
-import { ApiError, getProjects } from './api.mjs';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { resolveGitRepoRoot } from './commit-workflow.mjs';
 import {
   configPath,
   loadLocalConfig,
   upsertProjectMappingConfig
 } from './logwork-config.mjs';
-import { createResourceOptimiserSession } from './query-workflow.mjs';
+import { createMembershipProjectsFetcher } from './query-workflow.mjs';
 
 export async function listLogworkProjects({
   cwd = process.cwd(),
@@ -34,17 +36,35 @@ export async function upsertProjectMapping({
   projectName,
   tickets = [],
   keywords = [],
+  repos = [],
   scope = 'user',
   confirm,
   cwd = process.cwd(),
-  fetchProjects
+  fetchProjects,
+  resolveRepoRoot = resolveGitRepoRoot
 } = {}) {
   if (confirm !== true) {
     throw new Error('map_project requires confirm: true.');
   }
 
-  if (!Array.isArray(tickets) || !tickets.length) {
-    throw new Error('map_project requires at least one ticket prefix.');
+  const ticketList = Array.isArray(tickets) ? tickets : [];
+  const repoList = Array.isArray(repos) ? repos.filter((repo) => typeof repo === 'string' && repo.trim()) : [];
+  if (!ticketList.length && !repoList.length) {
+    throw new Error('map_project requires at least one ticket prefix or repo.');
+  }
+
+  // Commit drafts match a commit's git repo root, so a subfolder is stored as
+  // the root of the repo that contains it.
+  const repoRoots = [];
+  for (const repo of repoList) {
+    const trimmed = repo.trim();
+    const expanded = trimmed === '~' || /^~[\\/]/.test(trimmed) ? `${homedir()}${trimmed.slice(1)}` : trimmed;
+    const path = resolve(cwd, expanded);
+    try {
+      repoRoots.push(await resolveRepoRoot(path));
+    } catch (error) {
+      throw new Error(`${path} is not a git repository: ${error.message}`);
+    }
   }
 
   const projects = sanitizeProjects(await (fetchProjects || createMembershipProjectsFetcher())());
@@ -60,8 +80,9 @@ export async function upsertProjectMapping({
     cwd,
     scope,
     project: resolution.project,
-    tickets,
-    keywords
+    tickets: ticketList,
+    keywords,
+    repos: repoRoots
   });
 
   return {
@@ -72,8 +93,9 @@ export async function upsertProjectMapping({
     projects,
     summary: [
       `${result.created ? 'Created' : 'Updated'} project mapping for ${result.mapping.projectName}.`,
-      `Tickets: ${result.mapping.tickets.join(', ')}.`,
-      result.mapping.keywords.length ? `Keywords: ${result.mapping.keywords.join(', ')}.` : 'Keywords: none.'
+      result.mapping.tickets.length ? `Tickets: ${result.mapping.tickets.join(', ')}.` : 'Tickets: none.',
+      result.mapping.keywords.length ? `Keywords: ${result.mapping.keywords.join(', ')}.` : 'Keywords: none.',
+      result.mapping.repos?.length ? `Repos: ${result.mapping.repos.join(', ')}.` : 'Repos: none.'
     ].join('\n')
   };
 }
@@ -144,24 +166,7 @@ export function enrichRoPreviewWithJiraProjects(roPreview, jiraPreview) {
   };
 }
 
-function createMembershipProjectsFetcher() {
-  const session = createResourceOptimiserSession();
-  return async () => {
-    const { token, userId } = await session.get();
-    try {
-      return await getProjects(token, userId);
-    } catch (error) {
-      if (!(error instanceof ApiError) || error.status !== 401) {
-        throw error;
-      }
-
-      const refreshed = await session.get({ forceLogin: true });
-      return getProjects(refreshed.token, refreshed.userId);
-    }
-  };
-}
-
-function resolveProjectSelection(projects, { projectMemberId, projectName }) {
+export function resolveProjectSelection(projects, { projectMemberId, projectName }) {
   if (projectMemberId !== undefined && projectMemberId !== null && String(projectMemberId).trim() !== '') {
     const project = projects.find((candidate) => String(candidate.projectMemberId) === String(projectMemberId));
     return project

package/lib/query-workflow.mjs

@@ -1,10 +1,10 @@
-import { CONFIG } from './config.mjs';
 import { getFreshToken, getUserIdFromJwt } from './auth.mjs';
 import {
   ApiError,
   combineNormalizationDiagnostics,
   getDayLogs,
   getLogworkDay,
+  getProjects,
   getLogworkRejected,
   getNormalizationDiagnostics,
   getTimesheetRangeResult
@@ -289,6 +289,24 @@ export function createDayLogsFetcher() {
   };
 }
 
+// The user's RO project memberships (projectMemberId, projectId, projectName).
+export function createMembershipProjectsFetcher() {
+  const session = createResourceOptimiserSession();
+  return async () => {
+    const { token, userId } = await session.get();
+    try {
+      return await getProjects(token, userId);
+    } catch (error) {
+      if (!(error instanceof ApiError) || error.status !== 401) {
+        throw error;
+      }
+
+      const refreshed = await session.get({ forceLogin: true });
+      return getProjects(refreshed.token, refreshed.userId);
+    }
+  };
+}
+
 export function createResourceOptimiserSession() {
   let cached = null;
 

package/lib/reconciliation-workflow.mjs

@@ -1,4 +1,4 @@
-import { ApiError } from './api.mjs';
+import { ApiError } from './ro-api-http.mjs';
 import {
   getJiraIssueWorklogs,
   searchJiraIssues

package/lib/reminder-config.mjs

@@ -1,4 +1,6 @@
 import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { isAbsolute, resolve } from 'node:path';
 import { atomicWriteFile } from './atomic-file.mjs';
 import { reminderConfigPath } from './paths.mjs';
 
@@ -6,13 +8,15 @@ export const REMINDER_TARGETS = Object.freeze(['ro', 'jira', 'both']);
 export const WEEKDAY_NUMBERS = Object.freeze([1, 2, 3, 4, 5]);
 export const DEFAULT_REMINDER_TIME = '17:00';
 export const DEFAULT_REMINDER_TARGET = 'both';
+export const MAX_REMINDER_REPOS = 20;
 
 export function defaultReminderConfig() {
   return {
     enabled: false,
     time: DEFAULT_REMINDER_TIME,
     target: DEFAULT_REMINDER_TARGET,
-    days: [...WEEKDAY_NUMBERS]
+    days: [...WEEKDAY_NUMBERS],
+    repos: []
   };
 }
 
@@ -46,10 +50,42 @@ export function normalizeReminderConfig(config = {}) {
     enabled: Boolean(config.enabled),
     time,
     target,
-    days
+    days,
+    repos: normalizeReminderRepos(config.repos ?? defaults.repos)
   };
 }
 
+// Git repos whose commits the reminder summarizes. Stored as absolute paths
+// because the scheduled run starts in the helper home, not where the user
+// typed the command. `~` is expanded; relative paths resolve against cwd.
+export function normalizeReminderRepos(value, { cwd = process.cwd(), home = homedir() } = {}) {
+  if (value === undefined || value === null) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    throw new Error('Reminder repos must be a list of paths.');
+  }
+  const repos = [];
+  for (const item of value) {
+    const raw = String(item ?? '').trim();
+    if (!raw) {
+      continue;
+    }
+    if (/[\0\r\n]/.test(raw)) {
+      throw new Error('Reminder repo paths cannot contain control characters.');
+    }
+    const expanded = raw === '~' || /^~[\\/]/.test(raw) ? `${home}${raw.slice(1)}` : raw;
+    const absolute = isAbsolute(expanded) ? resolve(expanded) : resolve(cwd, expanded);
+    if (!repos.includes(absolute)) {
+      repos.push(absolute);
+    }
+  }
+  if (repos.length > MAX_REMINDER_REPOS) {
+    throw new Error(`Reminder repos are limited to ${MAX_REMINDER_REPOS} paths.`);
+  }
+  return repos;
+}
+
 export function normalizeReminderTime(value) {
   const time = String(value || '').trim();
   const match = /^(\d{2}):(\d{2})$/.exec(time);