@muzzamil-khan/redmine-agent-mcp 1.0.0

package/dist/workflows/logTimeWorkflow.js

@@ -0,0 +1,797 @@
+import axios from "axios";
+import { getDefaultTimeComment, getTimeEntryDefaults, requireRedmineEnv, } from "../config/env.js";
+import { getIssues, logTimeEntry } from "../services/redmine.js";
+import { isValidIssueId } from "../utils/validation.js";
+const TODAY = "Today";
+const MULTIPLE = "Multiple";
+/** @deprecated use MULTIPLE — still accepted from older clients */
+const ADD_MULTIPLE = "Add multiple";
+const OTHER = "Other";
+const USE_DEFAULT_COMMENT = "Use default comment";
+function todayIso() {
+    return new Date().toISOString().slice(0, 10);
+}
+function isValidDate(s) {
+    return /^\d{4}-\d{2}-\d{2}$/.test(s.trim());
+}
+function pairKey(spentOn, issueId) {
+    return `${spentOn}:${issueId}`;
+}
+function parsePairKey(key) {
+    const m = /^(\d{4}-\d{2}-\d{2}):(\d+)$/.exec(key.trim());
+    if (!m)
+        return undefined;
+    const issueId = Number(m[2]);
+    if (!isValidIssueId(issueId))
+        return undefined;
+    // `m[1]` is guaranteed by the regex when `m` is truthy.
+    return { spentOn: m[1], issueId };
+}
+function recentDateOptions(count) {
+    const out = [];
+    const d = new Date();
+    for (let i = 0; i < count; i++) {
+        const copy = new Date(d);
+        copy.setDate(copy.getDate() - i);
+        out.push(copy.toISOString().slice(0, 10));
+    }
+    return out;
+}
+function parseHours(hours) {
+    if (hours === undefined)
+        return undefined;
+    const n = typeof hours === "string" ? Number(hours) : hours;
+    return Number.isNaN(n) || n <= 0 ? undefined : n;
+}
+function expandDateToken(token) {
+    const t = token.trim();
+    if (t === TODAY || t.toLowerCase() === "today")
+        return todayIso();
+    if (isValidDate(t))
+        return t;
+    return null;
+}
+function normalizeDates(input) {
+    const raw = [
+        ...(input.dates ?? []),
+        ...(input.spentOn ? [input.spentOn] : []),
+    ];
+    const out = [];
+    for (const d of raw) {
+        const expanded = expandDateToken(d);
+        if (expanded)
+            out.push(expanded);
+    }
+    return [...new Set(out)];
+}
+function inferDatesFromPrompt(promptHint) {
+    if (!promptHint?.trim())
+        return undefined;
+    const p = promptHint.toLowerCase();
+    const isoDates = [
+        ...promptHint.matchAll(/\b(\d{4}-\d{2}-\d{2})\b/g),
+    ]
+        .map((m) => m[1])
+        .filter((d) => typeof d === "string");
+    if (isoDates.length > 0)
+        return [...new Set(isoDates)];
+    const out = [];
+    if (/\btoday\b/.test(p))
+        out.push(todayIso());
+    if (/\byesterday\b/.test(p)) {
+        const d = new Date();
+        d.setDate(d.getDate() - 1);
+        out.push(d.toISOString().slice(0, 10));
+    }
+    return out.length > 0 ? [...new Set(out)] : undefined;
+}
+function wantsExpandedDates(input) {
+    return (input.dates ?? []).some((d) => {
+        const t = d.trim();
+        return t === MULTIPLE || t === ADD_MULTIPLE;
+    });
+}
+function wantsOtherDate(input) {
+    return (input.dates ?? []).some((d) => d.trim() === OTHER);
+}
+function parseIssueIdsFromPrompt(promptHint) {
+    if (!promptHint?.trim())
+        return [];
+    const ids = [];
+    for (const m of promptHint.matchAll(/#(\d+)/g)) {
+        const n = Number(m[1]);
+        if (isValidIssueId(n))
+            ids.push(n);
+    }
+    for (const part of promptHint.split(/[,;\s]+/)) {
+        const n = Number(part.replace(/^#/, "").trim());
+        if (isValidIssueId(n))
+            ids.push(n);
+    }
+    return [...new Set(ids)];
+}
+function normalizeIssueIds(input) {
+    const fromPrompt = parseIssueIdsFromPrompt(input.promptHint);
+    const ids = [
+        ...fromPrompt,
+        ...(input.issueIds ?? []),
+        ...(input.issueId !== undefined ? [input.issueId] : []),
+    ];
+    return [...new Set(ids.filter((id) => isValidIssueId(id)))];
+}
+function parseIssueIdToken(token) {
+    const t = token.trim();
+    const leading = /^#?(\d+)/.exec(t);
+    if (!leading) {
+        return undefined;
+    }
+    const n = Number(leading[1]);
+    return isValidIssueId(n) ? n : undefined;
+}
+function parseCommaIssueIds(value) {
+    const ids = [];
+    for (const part of value.split(/[,;]+/)) {
+        const n = parseIssueIdToken(part);
+        if (n !== undefined) {
+            ids.push(n);
+        }
+    }
+    return [...new Set(ids)];
+}
+function normalizeIssueIdList(value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (typeof value === "number" && isValidIssueId(value)) {
+        return [value];
+    }
+    if (typeof value === "string") {
+        const t = value.trim();
+        if (t === OTHER) {
+            return [];
+        }
+        return parseCommaIssueIds(t);
+    }
+    if (Array.isArray(value)) {
+        const ids = [];
+        for (const item of value) {
+            if (typeof item === "number" && isValidIssueId(item)) {
+                ids.push(item);
+            }
+            else if (typeof item === "string") {
+                const one = parseIssueIdToken(item);
+                if (one !== undefined) {
+                    ids.push(one);
+                }
+                else {
+                    ids.push(...parseCommaIssueIds(item));
+                }
+            }
+        }
+        return [...new Set(ids)];
+    }
+    return [];
+}
+function normalizeDateIssuesMap(input, allDates) {
+    const out = {};
+    for (const [date, raw] of Object.entries(input.dateIssues ?? {})) {
+        if (!isValidDate(date)) {
+            continue;
+        }
+        const ids = normalizeIssueIdList(raw);
+        if (ids.length > 0) {
+            out[date] = ids;
+        }
+    }
+    const globalIds = normalizeIssueIds(input);
+    const hasPerDate = Object.keys(input.dateIssues ?? {}).some((d) => isValidDate(d));
+    if (globalIds.length > 0 && !hasPerDate) {
+        for (const d of allDates) {
+            out[d] = [...globalIds];
+        }
+    }
+    else if (globalIds.length > 0 && input.issueIds?.length) {
+        for (const d of allDates) {
+            if (!out[d]?.length) {
+                out[d] = [...globalIds];
+            }
+        }
+    }
+    if (input.activeDate &&
+        isValidDate(input.activeDate) &&
+        (input.issueIds?.length || input.issueId)) {
+        const activeIds = normalizeIssueIds({
+            ...(input.issueIds !== undefined ? { issueIds: input.issueIds } : {}),
+            ...(input.issueId !== undefined ? { issueId: input.issueId } : {}),
+        });
+        if (activeIds.length > 0) {
+            out[input.activeDate] = [
+                ...new Set([...(out[input.activeDate] ?? []), ...activeIds]),
+            ];
+        }
+    }
+    return out;
+}
+function datesAwaitingIssues(allDates, dateIssues) {
+    return allDates.filter((d) => !(dateIssues[d]?.length ?? 0));
+}
+function hasAnyDateIssues(dateIssues, allDates) {
+    return allDates.some((d) => (dateIssues[d]?.length ?? 0) > 0);
+}
+function buildAllPairsFromDateIssues(allDates, dateIssues) {
+    const pairs = [];
+    for (const spentOn of allDates) {
+        for (const issueId of dateIssues[spentOn] ?? []) {
+            if (isValidIssueId(issueId)) {
+                pairs.push({ spentOn, issueId });
+            }
+        }
+    }
+    return pairs;
+}
+function normalizeSkippedPairs(input) {
+    const set = new Set();
+    for (const key of input.skippedPairs ?? []) {
+        const p = parsePairKey(key);
+        if (p)
+            set.add(pairKey(p.spentOn, p.issueId));
+    }
+    return set;
+}
+function findEntry(entries, spentOn, issueId) {
+    return entries.find((e) => e.spentOn === spentOn && e.issueId === issueId && e.hours > 0);
+}
+function isPairComplete(entries, spentOn, issueId) {
+    const e = findEntry(entries, spentOn, issueId);
+    return e !== undefined && e.comments.trim().length > 0;
+}
+function isPairSkipped(skipped, spentOn, issueId) {
+    return skipped.has(pairKey(spentOn, issueId));
+}
+function stepData(step, base) {
+    return { step, ...base };
+}
+function customInputPrompt(field, message, data) {
+    return {
+        success: false,
+        needsInput: true,
+        question: {
+            field,
+            question: message,
+        },
+        data: stepData(data.step, {
+            ...data,
+            awaitingCustomInput: field,
+            hint: "Reply in chat with your value, then retry this tool with that field set.",
+        }),
+    };
+}
+function previewEntry(draft, activityId, billableHoursFieldId) {
+    return {
+        issueId: draft.issueId,
+        hours: draft.hours,
+        spentOn: draft.spentOn,
+        activityId,
+        billableHoursFieldId,
+        billableHours: String(draft.hours),
+        comments: draft.comments,
+    };
+}
+function datesQuestion() {
+    return {
+        field: "dates",
+        question: "Step 1 — When should time be logged?",
+        options: [TODAY, MULTIPLE, OTHER],
+        allowMultiple: false,
+    };
+}
+function datesExpandedQuestion() {
+    return {
+        field: "dates",
+        question: "Step 1 — Select all dates to log time on",
+        options: [...recentDateOptions(14), OTHER],
+        allowMultiple: true,
+    };
+}
+function issueSubjectsToRecord(subjects) {
+    const out = {};
+    for (const [id, subject] of Object.entries(subjects)) {
+        if (subject.trim()) {
+            out[String(id)] = subject;
+        }
+    }
+    return out;
+}
+function pairQuestionTitle(pair, subjects, prefix) {
+    const title = subjects[pair.issueId]?.trim();
+    const suffix = title ? `: ${title}` : "";
+    return `${prefix} #${pair.issueId} on ${pair.spentOn}${suffix}?`;
+}
+async function resolveIssueSubjects(input, issueIds) {
+    const map = {};
+    for (const [key, subject] of Object.entries(input.issueSubjects ?? {})) {
+        const id = Number(key);
+        if (isValidIssueId(id) && subject?.trim()) {
+            map[id] = subject.trim();
+        }
+    }
+    for (const opt of input.issueOptions ?? []) {
+        if (!isValidIssueId(opt.issueId)) {
+            continue;
+        }
+        if (opt.subject?.trim()) {
+            map[opt.issueId] = opt.subject.trim();
+        }
+        else if (opt.label?.trim()) {
+            const m = /^#\d+\s*—\s*(.+)$/.exec(opt.label.trim());
+            if (m?.[1]) {
+                map[opt.issueId] = m[1].trim();
+            }
+        }
+    }
+    const needsLookup = issueIds.some((id) => !map[id]);
+    if (needsLookup) {
+        const loaded = await fetchIssueOptions();
+        if (!("error" in loaded)) {
+            for (const issue of loaded.issues) {
+                map[issue.id] = issue.subject;
+            }
+        }
+    }
+    return map;
+}
+function batchDateIssuesQuestions(dates, issues) {
+    const options = issues.map((i) => `${i.id} — ${i.subject}`);
+    return dates.map((spentOn) => ({
+        id: spentOn,
+        field: "dateIssues",
+        question: `Step 2 — Issues for ${spentOn}? (multi-select; option is id — title, or Other + comma-separated IDs)`,
+        options: [...options, OTHER],
+        allowMultiple: true,
+    }));
+}
+function batchNeedsInput(step, field, title, questions, data) {
+    return {
+        success: false,
+        needsInput: true,
+        question: {
+            field,
+            question: title,
+        },
+        questions,
+        data: stepData(step, {
+            ...data,
+            batchMode: true,
+            batchField: field,
+            hint: field === "dateIssues"
+                ? `Show all ${questions.length} questions in ONE AskQuestion (id = date YYYY-MM-DD). Retry with dateIssues: { "YYYY-MM-DD": [issueId, ...] } — use comma-separated string for a date if Other.`
+                : `Show all ${questions.length} questions in ONE AskQuestion (use question id as answer key). Then retry with ${field} object keyed by id.`,
+        }),
+    };
+}
+function batchHoursQuestions(pairs, subjects) {
+    return pairs.map((p) => {
+        const id = pairKey(p.spentOn, p.issueId);
+        return {
+            id,
+            field: "pairHours",
+            question: pairQuestionTitle(p, subjects, "Step 3 — Hours for"),
+            options: ["1", "2", "4", "8", OTHER],
+        };
+    });
+}
+function batchCommentQuestions(pairs, defaultComment, subjects) {
+    return pairs.map((p) => {
+        const id = pairKey(p.spentOn, p.issueId);
+        const base = pairQuestionTitle(p, subjects, "Step 4 — Comment for").replace(/\?$/, "");
+        return {
+            id,
+            field: "pairComments",
+            question: `${base} (default: "${defaultComment}")?`,
+            options: [USE_DEFAULT_COMMENT, OTHER],
+            allowMultiple: false,
+        };
+    });
+}
+function mergePairHours(input) {
+    const out = { ...(input.pairHours ?? {}) };
+    if (input.activeDate &&
+        isValidDate(input.activeDate) &&
+        input.activeIssueId &&
+        input.hours !== undefined) {
+        out[pairKey(input.activeDate, input.activeIssueId)] = input.hours;
+    }
+    return out;
+}
+function mergePairComments(input) {
+    const out = { ...(input.pairComments ?? {}) };
+    if (input.activeDate &&
+        isValidDate(input.activeDate) &&
+        input.activeIssueId) {
+        const key = pairKey(input.activeDate, input.activeIssueId);
+        if (input.commentChoice === "default") {
+            out[key] = "default";
+        }
+        else if (input.comments?.trim()) {
+            out[key] = input.comments.trim();
+        }
+    }
+    return out;
+}
+function pairsAwaitingHours(included, entries, pairHours) {
+    return included.filter((p) => {
+        const key = pairKey(p.spentOn, p.issueId);
+        if (findEntry(entries, p.spentOn, p.issueId)) {
+            return false;
+        }
+        return parseHours(pairHours[key]) === undefined;
+    });
+}
+function applyPairHoursToEntries(entries, included, pairHours) {
+    const next = entries.map((e) => ({ ...e }));
+    for (const p of included) {
+        const key = pairKey(p.spentOn, p.issueId);
+        const hours = parseHours(pairHours[key]);
+        if (hours === undefined) {
+            continue;
+        }
+        const idx = next.findIndex((e) => e.spentOn === p.spentOn && e.issueId === p.issueId);
+        const draft = {
+            issueId: p.issueId,
+            hours,
+            spentOn: p.spentOn,
+            comments: "",
+        };
+        if (idx >= 0) {
+            next[idx] = draft;
+        }
+        else {
+            next.push(draft);
+        }
+    }
+    return next;
+}
+function pairsAwaitingComments(entries, skipped, pairComments) {
+    const out = [];
+    for (const e of entries) {
+        if (isPairSkipped(skipped, e.spentOn, e.issueId)) {
+            continue;
+        }
+        if (e.hours <= 0) {
+            continue;
+        }
+        const key = pairKey(e.spentOn, e.issueId);
+        const answer = pairComments[key]?.trim();
+        if (!answer || answer === OTHER) {
+            out.push({ spentOn: e.spentOn, issueId: e.issueId });
+            continue;
+        }
+        if (e.comments.trim().length > 0) {
+            continue;
+        }
+    }
+    return out;
+}
+function applyPairCommentsToEntries(entries, pairComments) {
+    const defaultComment = getDefaultTimeComment();
+    return entries.map((e) => {
+        const key = pairKey(e.spentOn, e.issueId);
+        const answer = pairComments[key]?.trim();
+        if (!answer || answer === OTHER) {
+            return e;
+        }
+        if (answer === "default" ||
+            answer === USE_DEFAULT_COMMENT ||
+            answer.toLowerCase() === "use default comment") {
+            return { ...e, comments: defaultComment };
+        }
+        return { ...e, comments: answer };
+    });
+}
+function buildPreviewPayload(drafts) {
+    const { activityId, billableHoursFieldId } = getTimeEntryDefaults();
+    const preview = drafts.map((d) => previewEntry(d, activityId, billableHoursFieldId));
+    const previewLines = drafts.map((d, i) => `${i + 1}. ${d.spentOn} | #${d.issueId} | ${d.hours}h billable | "${d.comments}"`);
+    return {
+        preview,
+        previewLines,
+        previewText: previewLines.join("\n"),
+    };
+}
+function confirmWithPreviewResponse(drafts, allDates, dateIssues, skippedPairs) {
+    const { preview, previewLines, previewText } = buildPreviewPayload(drafts);
+    return {
+        success: false,
+        needsInput: true,
+        question: {
+            field: "confirmSave",
+            question: `Step 5 — Review ${drafts.length} time entr${drafts.length === 1 ? "y" : "ies"} below, then confirm save to Redmine.`,
+            options: ["yes", "no"],
+        },
+        data: stepData("preview", {
+            entries: drafts,
+            dates: allDates,
+            dateIssues,
+            skippedPairs,
+            count: drafts.length,
+            summary: `${drafts.length} time entr${drafts.length === 1 ? "y" : "ies"} ready to log`,
+            preview,
+            previewLines,
+            previewText,
+            hint: "Show previewText to the user, then retry with confirmSave: yes to save",
+        }),
+    };
+}
+async function fetchIssueOptions() {
+    try {
+        const data = await getIssues({
+            assignedToId: "me",
+            statusId: "*",
+            limit: 25,
+        });
+        return {
+            issues: (data.issues ?? []),
+        };
+    }
+    catch {
+        return { error: "Failed to load issues" };
+    }
+}
+async function saveDrafts(drafts) {
+    const { activityId, billableHoursFieldId } = getTimeEntryDefaults();
+    const { baseUrl } = requireRedmineEnv();
+    const saved = [];
+    for (const draft of drafts) {
+        const result = await logTimeEntry({
+            issueId: draft.issueId,
+            hours: draft.hours,
+            spentOn: draft.spentOn,
+            activityId,
+            billableHoursFieldId,
+            billableHours: String(draft.hours),
+            comments: draft.comments,
+        });
+        const entry = result.time_entry;
+        saved.push({
+            timeEntryId: entry.id,
+            issueId: draft.issueId,
+            issueUrl: `${baseUrl}/issues/${draft.issueId}`,
+            hours: draft.hours,
+            spentOn: draft.spentOn,
+            billableHours: String(draft.hours),
+            comments: draft.comments,
+        });
+    }
+    return {
+        success: true,
+        data: {
+            count: saved.length,
+            entries: saved,
+            batch: true,
+        },
+    };
+}
+function resolveAllPendingComments(entries, input) {
+    const defaultComment = getDefaultTimeComment();
+    const pending = entries.filter((e) => e.hours > 0 && e.comments.trim() === "");
+    if (pending.length === 0) {
+        return [...entries];
+    }
+    if (input.commentChoice === "custom") {
+        const text = input.comments?.trim();
+        if (!text || text === OTHER) {
+            return customInputPrompt("comments", "Enter comment for all pending entries, then retry with commentChoice: custom and comments", stepData("comments", { entries, suggestedComment: defaultComment }));
+        }
+        return entries.map((e) => e.hours > 0 && e.comments.trim() === ""
+            ? { ...e, comments: text }
+            : e);
+    }
+    if (input.commentChoice === "default" ||
+        input.comments?.trim() === USE_DEFAULT_COMMENT) {
+        return entries.map((e) => e.hours > 0 && e.comments.trim() === ""
+            ? { ...e, comments: defaultComment }
+            : e);
+    }
+    const text = input.comments?.trim();
+    if (text && text !== OTHER) {
+        return entries.map((e) => e.hours > 0 && e.comments.trim() === ""
+            ? { ...e, comments: text }
+            : e);
+    }
+    return entries;
+}
+function completedDrafts(entries) {
+    return entries.filter((e) => e.hours > 0 && e.comments.trim().length > 0);
+}
+function baseState(allDates, dateIssues, entries, skipped, allPairs) {
+    return {
+        dates: allDates,
+        dateIssues,
+        entries,
+        skippedPairs: [...skipped],
+        pendingPairs: allPairs
+            .filter((p) => !isPairSkipped(skipped, p.spentOn, p.issueId))
+            .filter((p) => !isPairComplete(entries, p.spentOn, p.issueId))
+            .map((p) => ({ spentOn: p.spentOn, issueId: p.issueId })),
+    };
+}
+export async function logTimeWorkflow(input) {
+    const entries = (input.entries ?? []).map((e) => ({ ...e }));
+    let dateIssues = {};
+    let skipped = normalizeSkippedPairs(input);
+    // —— Step 1: dates ——
+    let allDates = normalizeDates(input);
+    if (allDates.length === 0) {
+        const inferred = inferDatesFromPrompt(input.promptHint);
+        if (inferred?.length)
+            allDates = inferred;
+    }
+    if (wantsOtherDate(input) && allDates.length === 0) {
+        return customInputPrompt("spentOn", "You chose Other — enter the date in chat (YYYY-MM-DD), then retry with spentOn or dates[]", stepData("dates", { dates: input.dates }));
+    }
+    if (allDates.length === 0) {
+        if (wantsExpandedDates(input)) {
+            return {
+                success: false,
+                needsInput: true,
+                question: datesExpandedQuestion(),
+                data: stepData("dates", {
+                    hint: "Select one or more dates, or Other for a custom date",
+                }),
+            };
+        }
+        return {
+            success: false,
+            needsInput: true,
+            question: datesQuestion(),
+            data: stepData("dates", {
+                hint: "Pick Today, Multiple, or Other — one choice only",
+            }),
+        };
+    }
+    if (wantsExpandedDates(input) && allDates.length < 2) {
+        return {
+            success: false,
+            needsInput: true,
+            question: datesExpandedQuestion(),
+            data: stepData("dates", {
+                dates: allDates,
+                hint: "Multiple — select one or more dates (or Other for a custom date)",
+            }),
+        };
+    }
+    // —— Step 2: batch issues per date (one panel per date, all on one page) ——
+    dateIssues = normalizeDateIssuesMap(input, allDates);
+    const issuesAwaiting = datesAwaitingIssues(allDates, dateIssues);
+    if (issuesAwaiting.length > 0) {
+        const loaded = await fetchIssueOptions();
+        const issueList = "error" in loaded ? [] : loaded.issues;
+        const showDates = Object.keys(dateIssues).length === 0 ? allDates : issuesAwaiting;
+        return batchNeedsInput("issues", "dateIssues", `Step 2 — Select issue(s) for each date (${showDates.length} date(s), answer all)`, batchDateIssuesQuestions(showDates, issueList), {
+            dates: allDates,
+            dateIssues,
+            entries,
+            issueOptions: issueList.map((i) => ({
+                issueId: i.id,
+                subject: i.subject,
+                label: `#${i.id} — ${i.subject}`,
+            })),
+            issueSubjects: issueSubjectsToRecord(Object.fromEntries(issueList.map((i) => [i.id, i.subject]))),
+            ...("error" in loaded
+                ? {
+                    hint: "Assigned issues could not be loaded — use Other per date and pass comma-separated IDs in dateIssues",
+                }
+                : {}),
+        });
+    }
+    if (!hasAnyDateIssues(dateIssues, allDates)) {
+        return {
+            success: false,
+            error: "No issues selected for any date",
+            data: { dates: allDates, dateIssues },
+        };
+    }
+    const allPairs = buildAllPairsFromDateIssues(allDates, dateIssues);
+    const pairHours = mergePairHours(input);
+    const pairComments = mergePairComments(input);
+    const gridIssueIds = [...new Set(allPairs.map((p) => p.issueId))];
+    const issueSubjectMap = await resolveIssueSubjects(input, gridIssueIds);
+    const sharedData = () => ({
+        ...baseState(allDates, dateIssues, entries, skipped, allPairs),
+        issueSubjects: issueSubjectsToRecord(issueSubjectMap),
+        issueOptions: gridIssueIds.map((id) => ({
+            issueId: id,
+            subject: issueSubjectMap[id] ?? "",
+            label: issueSubjectMap[id]
+                ? `#${id} — ${issueSubjectMap[id]}`
+                : `#${id}`,
+        })),
+    });
+    if (allPairs.length === 0) {
+        return {
+            success: false,
+            error: "No date×task combinations — select issues per date in step 2",
+            data: { dates: allDates, dateIssues },
+        };
+    }
+    // —— Step 3: batch hours (all date×task pairs from step 2) ——
+    let workingEntries = applyPairHoursToEntries(entries, allPairs, pairHours);
+    const hoursAwaiting = pairsAwaitingHours(allPairs, workingEntries, pairHours);
+    if (hoursAwaiting.length > 0) {
+        return batchNeedsInput("hours", "pairHours", `Step 3 — Hours for ${hoursAwaiting.length} pair(s) (answer all)`, batchHoursQuestions(hoursAwaiting, issueSubjectMap), {
+            ...sharedData(),
+            entries: workingEntries,
+        });
+    }
+    entries.length = 0;
+    entries.push(...workingEntries);
+    // —— Step 4: batch comments (all pairs on one page) ——
+    const defaultComment = getDefaultTimeComment();
+    workingEntries = applyPairCommentsToEntries(entries, pairComments);
+    const commentsAwaiting = pairsAwaitingComments(workingEntries, skipped, pairComments);
+    if (commentsAwaiting.length > 0) {
+        return batchNeedsInput("comments", "pairComments", `Step 4 — Comment for ${commentsAwaiting.length} pair(s) (answer all; use "${USE_DEFAULT_COMMENT}" or custom text)`, batchCommentQuestions(commentsAwaiting, defaultComment, issueSubjectMap), {
+            ...sharedData(),
+            entries: workingEntries,
+            pairHours,
+            suggestedComment: defaultComment,
+        });
+    }
+    entries.length = 0;
+    entries.push(...workingEntries);
+    // Legacy: single commentChoice applies default to all pending
+    if (input.commentChoice === "default" ||
+        (input.comments?.trim() === USE_DEFAULT_COMMENT && !Object.keys(pairComments).length)) {
+        const batchResolved = resolveAllPendingComments(entries, input);
+        if (Array.isArray(batchResolved)) {
+            entries.length = 0;
+            entries.push(...batchResolved);
+        }
+    }
+    const drafts = completedDrafts(entries);
+    if (drafts.length === 0) {
+        return {
+            success: false,
+            error: "No time entries to save — complete hours and comments for selected issues",
+            data: { dates: allDates, dateIssues },
+        };
+    }
+    if (!input.confirmSave) {
+        return confirmWithPreviewResponse(drafts, allDates, dateIssues, [...skipped]);
+    }
+    if (input.confirmSave !== "yes") {
+        return {
+            success: false,
+            error: "Time entries not saved (confirmation was not yes)",
+        };
+    }
+    try {
+        return await saveDrafts(drafts);
+    }
+    catch (error) {
+        return formatSaveError(error);
+    }
+}
+function formatSaveError(error) {
+    if (axios.isAxiosError(error)) {
+        const status = error.response?.status;
+        const errors = error.response?.data;
+        if (status === 403) {
+            return {
+                success: false,
+                error: "Forbidden: you do not have permission to log time on one or more issues",
+            };
+        }
+        if (status === 422 && errors?.errors?.length) {
+            return {
+                success: false,
+                error: errors.errors.join("; "),
+            };
+        }
+    }
+    return {
+        success: false,
+        error: "Failed to log time on Redmine",
+    };
+}
+//# sourceMappingURL=logTimeWorkflow.js.map