@knpkv/jira-clockify 1.3.0 → 1.4.1

package/dist/src/services/ReconcileService.js

@@ -16,47 +16,196 @@
  *
  * - Jira worklogs carry no Clockify id, so matching is heuristic (ticket + day), never entry-to-entry.
  * - Clockify entries must encode the ticket as `[KEY] …` or `KEY: …` in the description; entries
- *   without a parseable key (or still running) are ignored.
+ *   without a parseable key remain outside reconciliation proposals. Running entries are excluded from totals.
  * - Days are local calendar days so the buckets line up with how a person reads their timesheet.
  *
  * @module
  */
-import { ClockifyApiClient } from "@knpkv/clockify-api-client";
-import { JiraApiClient } from "@knpkv/jira-api-client";
+import { ClockifyApi, make as makeClockifyApi } from "@knpkv/clockify-api-client";
+import { JiraApiClient, make as makeJiraApi } from "@knpkv/jira-api-client";
 import { JiraAuth } from "@knpkv/jira-cli/JiraAuth";
+import * as Clock from "effect/Clock";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as HttpClient from "effect/http/HttpClient";
+import * as HttpClientRequest from "effect/http/HttpClientRequest";
+import * as HttpClientResponse from "effect/http/HttpClientResponse";
 import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
 import * as Predicate from "effect/Predicate";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import { activeWindows, attributeSession, bothSides, buildSessionProposals, deterministicAttribution, expandHomePath, splitCredits } from "../agent/sessions.js";
+import * as SourceConsumption from "../agent/sourceConsumption.js";
+import * as WriterGuard from "../cli/writerGuard.js";
+import { localDay, nextLocalMidnight, splitIntervalByLocalDay } from "../utils/time.js";
+import { AgentSessionReader } from "./AgentSessionReader.js";
 import { ClockifyAuth } from "./ClockifyAuth.js";
 import { ConfigService } from "./ConfigService.js";
+import { HomeDirectory } from "./HomeDirectory.js";
+import { postJiraWorklog } from "./internal/JiraWorklogPost.js";
+import { readJiraDeletionEvidence } from "./ProviderDeletion.js";
+import { jiraWorklogDescription } from "./SavedEntries.js";
+import { SessionAttributor } from "./SessionAttributor.js";
+import { SourceLedger } from "./SourceLedger.js";
 import { TimerService } from "./TimerService.js";
+export { bothSides } from "../agent/sessions.js";
+const mergeIntervals = (intervals) => {
+    const sorted = [...intervals].sort((left, right) => left.startMs - right.startMs || left.endMs - right.endMs);
+    const merged = [];
+    for (const interval of sorted) {
+        const previous = merged.at(-1);
+        if (previous === undefined || interval.startMs > previous.endMs) {
+            merged.push(interval);
+        }
+        else if (interval.endMs > previous.endMs) {
+            merged[merged.length - 1] = { startMs: previous.startMs, endMs: interval.endMs };
+        }
+    }
+    return merged;
+};
+const subtractIntervals = (source, consumed) => {
+    let remaining = [source];
+    for (const interval of mergeIntervals(consumed)) {
+        remaining = remaining.flatMap((candidate) => {
+            if (interval.endMs <= candidate.startMs || interval.startMs >= candidate.endMs)
+                return [candidate];
+            return [
+                ...(interval.startMs > candidate.startMs
+                    ? [{ startMs: candidate.startMs, endMs: Math.min(interval.startMs, candidate.endMs) }]
+                    : []),
+                ...(interval.endMs < candidate.endMs
+                    ? [{ startMs: Math.max(interval.endMs, candidate.startMs), endMs: candidate.endMs }]
+                    : [])
+            ];
+        });
+    }
+    return remaining.filter((interval) => interval.endMs > interval.startMs);
+};
 export class ReconcileError extends Data.TaggedError("ReconcileError") {
 }
+/**
+ * Jira floors worklogs to the minute. Clockify proposals retain exact positive seconds;
+ * each provider's proposal floor matches its own confirmation floor.
+ */
+const MINIMUM_PROPOSAL_SECONDS = 60;
+/**
+ * How many Coding Agent calls may be in flight at once.
+ *
+ * Each call spawns a CLI process that takes tens of seconds, so running them one at a time makes
+ * the command look hung. But these processes are heavy and contend for the machine: measured at
+ * four, a batch took ~75s and every call in the *second* batch hit the timeout, turning
+ * parallelism into lost attributions. Two keeps calls comfortably inside their timeout while still
+ * halving the wall clock — faster in practice than four, because nothing is thrown away.
+ */
+const ATTRIBUTOR_CONCURRENCY = 2;
+/**
+ * Characters of digest a *description* prompt spends on one work item.
+ *
+ * Smaller than a whole session digest on purpose: what was worked on is stated early, and a bucket
+ * that spans four sessions must not spend four times the budget to say one sentence.
+ */
+const DESCRIBE_DIGEST_CHARS = 3_000;
+/**
+ * How much digest text one Coding Agent call may carry, and how many sessions.
+ *
+ * Sessions are batched because a call's cost is almost entirely fixed: measured against the real
+ * CLI, one session cost $0.080 and 6.3s while seven together cost $0.049 and 10.2s. Chunking rather
+ * than one giant call bounds two things — the prompt, and the damage a single timeout does, since a
+ * failed chunk costs the attributions of every session in it.
+ */
+const ATTRIBUTOR_BATCH_CHARS = 24_000;
+const ATTRIBUTOR_BATCH_SESSIONS = 8;
+/** Split requests into calls, cut on whichever bound is reached first. */
+const batchRequests = (requests) => {
+    const batches = [];
+    let current = [];
+    let chars = 0;
+    for (const request of requests) {
+        const tooManyChars = current.length > 0 && chars + request.digest.length > ATTRIBUTOR_BATCH_CHARS;
+        if (tooManyChars || current.length >= ATTRIBUTOR_BATCH_SESSIONS) {
+            batches.push(current);
+            current = [];
+            chars = 0;
+        }
+        current.push(request);
+        chars += request.digest.length;
+    }
+    if (current.length > 0)
+        batches.push(current);
+    return batches;
+};
+/**
+ * Provider totals that may size a write. Compatibility Jira rows remain visible, but cannot settle
+ * an executable gap until the same credential and account have been verified.
+ *
+ * @internal
+ */
+export const recordedForExecution = (recorded, jiraAvailability) => jiraAvailability === undefined || jiraAvailability === "verified"
+    ? recorded
+    : recorded.map((row) => ({
+        ...row,
+        jiraSeconds: 0,
+        intervals: row.intervals.filter((interval) => interval.source !== "jira" && interval.entry?.source !== "jira")
+    }));
 export class ReconcileService extends Context.Service()("jcf/ReconcileService") {
 }
 // ---------------------------------------------------------------------------
 // Pure helpers (exported for testing)
 // ---------------------------------------------------------------------------
+/**
+ * One digest per proposal: the sessions behind it, joined and bounded.
+ *
+ * Bounded twice over — each session's digest is already capped when the transcript is read, and a
+ * bucket that ran across several sessions is truncated again here, because a prompt that grows with
+ * the number of sessions in a day is a prompt that eventually times out.
+ */
+export const bucketDigest = (proposal, digests) => {
+    const parts = [];
+    let length = 0;
+    for (const sessionId of proposal.sessionIds) {
+        const digest = digests.get(sessionId)?.trim();
+        if (digest === undefined || digest === "")
+            continue;
+        const remaining = DESCRIBE_DIGEST_CHARS - length;
+        if (remaining <= 0)
+            break;
+        const clipped = digest.length > remaining ? digest.slice(0, remaining) : digest;
+        parts.push(clipped);
+        length += clipped.length + 1;
+    }
+    return parts.join("\n");
+};
+/**
+ * Standing Attributions with `~` resolved, so the form the config command stores actually matches.
+ *
+ * `jcf config set session-ticket ~/dev/docs PROJ-42` deliberately keeps the `~` — a config file that
+ * reads back the way it was typed is the point — but attribution compares against an absolute
+ * working directory, where `~/dev/docs` can never match anything. Session Roots have always been
+ * expanded on read for exactly this reason; this is the same treatment for the other prefix.
+ */
+export const expandedStandingMap = (map, home) => Object.fromEntries(Object.entries(map).map(([prefix, ticketKey]) => [expandHomePath(prefix, home), ticketKey]));
 /** Parse a ticket key from a Clockify description (`[KEY] summary` or `KEY: summary`). */
 export const parseTicketKey = (description) => {
     const desc = description ?? "";
-    const bracket = desc.match(/^\[([^\]]+)\]/);
-    if (bracket?.[1])
-        return bracket[1].trim();
+    const bracket = desc.match(/^\[\s*([A-Za-z][A-Za-z0-9]*-\d+)\s*\]/);
+    const bracketKey = bracket?.[1];
+    if (bracketKey !== undefined && bracketKey !== "")
+        return bracketKey.trim();
     const colon = desc.match(/^([A-Za-z][A-Za-z0-9]*-\d+):/);
-    if (colon?.[1])
-        return colon[1].trim();
+    const colonKey = colon?.[1];
+    if (colonKey !== undefined && colonKey !== "")
+        return colonKey.trim();
     return null;
 };
-/** Local calendar day (`YYYY-MM-DD`) of an instant — matches how a timesheet reads. */
-export const localDay = (date) => {
-    const y = date.getFullYear();
-    const m = String(date.getMonth() + 1).padStart(2, "0");
-    const d = String(date.getDate()).padStart(2, "0");
-    return `${y}-${m}-${d}`;
-};
+/**
+ * Local calendar day (`YYYY-MM-DD`) of an instant — matches how a timesheet reads.
+ * Re-exported from the shared time utilities so every day bucket in jcf (reconcile rows,
+ * Attributed Intervals, Proposed Worklogs) is keyed by one definition.
+ */
+export { localDay };
 /** Strip the leading ticket marker (`[KEY] ` or `KEY: `) so the remainder reads as a plain note. */
 export const stripTicketPrefix = (description) => description
     .replace(/^\[[^\]]*\]\s*/, "")
@@ -72,7 +221,7 @@ export const combineDescriptions = (descriptions) => {
     const parts = [];
     for (const raw of descriptions) {
         const text = stripTicketPrefix(raw ?? "");
-        if (text && !seen.has(text)) {
+        if (text !== "" && !seen.has(text)) {
             seen.add(text);
             parts.push(text);
         }
@@ -88,19 +237,35 @@ export const buildReconcileRows = (clockify, jira) => {
     const clockifyByKey = new Map();
     const jiraByKey = new Map();
     const descByKey = new Map();
+    const intervalsByKey = new Map();
     const meta = new Map();
+    const addInterval = (k, entry, source) => {
+        if (entry.startMs === undefined || entry.endMs === undefined)
+            return;
+        intervalsByKey.set(k, [
+            ...(intervalsByKey.get(k) ?? []),
+            {
+                endMs: entry.endMs,
+                source,
+                startMs: entry.startMs,
+                ...(entry.entry !== undefined && { entry: entry.entry })
+            }
+        ]);
+    };
     for (const e of clockify) {
         const k = key(e.ticketKey, e.day);
         clockifyByKey.set(k, (clockifyByKey.get(k) ?? 0) + e.seconds);
         const descs = descByKey.get(k) ?? [];
         descs.push(e.description);
         descByKey.set(k, descs);
+        addInterval(k, e, "clockify");
         if (!meta.has(k))
             meta.set(k, { ticketKey: e.ticketKey, day: e.day });
     }
     for (const e of jira) {
         const k = key(e.ticketKey, e.day);
         jiraByKey.set(k, (jiraByKey.get(k) ?? 0) + e.seconds);
+        addInterval(k, e, "jira");
         if (!meta.has(k))
             meta.set(k, { ticketKey: e.ticketKey, day: e.day });
     }
@@ -110,10 +275,18 @@ export const buildReconcileRows = (clockify, jira) => {
         day,
         clockifySeconds: clockifyByKey.get(k) ?? 0,
         jiraSeconds: jiraByKey.get(k) ?? 0,
-        clockifyDescription: combineDescriptions(descByKey.get(k) ?? [])
+        clockifyDescription: combineDescriptions(descByKey.get(k) ?? []),
+        intervals: (intervalsByKey.get(k) ?? []).sort((a, b) => a.startMs - b.startMs)
     }))
         .sort((a, b) => (a.day === b.day ? a.ticketKey.localeCompare(b.ticketKey) : a.day.localeCompare(b.day)));
 };
+const ReadableWorklogFields = Schema.Struct({
+    id: Schema.String.check(Schema.isPattern(/\S/u)),
+    author: Schema.Struct({ accountId: Schema.NonEmptyString }),
+    started: Schema.NonEmptyString,
+    timeSpentSeconds: Schema.Natural
+});
+const isReadableWorklog = Schema.is(ReadableWorklogFields);
 const issueKey = (issue) => {
     if (!Predicate.isObject(issue))
         return null;
@@ -126,116 +299,1134 @@ const toRawWorklog = (value) => {
     const author = Predicate.isObject(value.author) ? value.author : undefined;
     const accountId = author?.accountId;
     return {
+        ...((Predicate.isString(value.id)) && { id: value.id }),
+        comment: value.comment,
         ...((Predicate.isString(accountId)) && { author: { accountId } }),
         ...((Predicate.isString(value.started)) && { started: value.started }),
         ...((Predicate.isNumber(value.timeSpentSeconds)) && { timeSpentSeconds: value.timeSpentSeconds })
     };
 };
-const toRawWorklogs = (response) => {
-    if (!Predicate.isObject(response) || !Array.isArray(response.worklogs))
-        return [];
-    return response.worklogs.flatMap((worklog) => {
-        const parsed = toRawWorklog(worklog);
-        return parsed ? [parsed] : [];
-    });
-};
 export const layer = Layer.effect(ReconcileService, Effect.gen(function* () {
-    const clockify = yield* ClockifyApiClient;
     const clockifyAuth = yield* ClockifyAuth;
     const jira = yield* JiraApiClient;
     const jiraAuth = yield* JiraAuth;
+    const httpClient = yield* HttpClient.HttpClient;
     const config = yield* ConfigService;
+    const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const home = (yield* HomeDirectory).path;
     const timer = yield* TimerService;
+    const sessionReader = yield* AgentSessionReader;
+    const attributor = yield* SessionAttributor;
+    const sourceLedger = yield* SourceLedger;
+    const provideGuard = (effect) => effect.pipe(Effect.provideService(ConfigService, config), Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path.Path, path));
     const getAuth = clockifyAuth.getConfig.pipe(Effect.mapError((e) => new ReconcileError({ message: e.message })));
-    // Tally Clockify entries in the period by (ticket, day).
-    const clockifyTally = (period) => Effect.gen(function* () {
+    /** One decoded credential and endpoint back every Clockify read and write in this operation. */
+    const clockifyWriteSnapshot = Effect.gen(function* () {
         const auth = yield* getAuth;
-        const entries = yield* clockify.getTimeEntries(auth.workspaceId, auth.userId, {
-            start: period.from.toISOString(),
-            end: period.to.toISOString()
+        const endpoint = yield* Effect.try({
+            try: () => new URL(auth.baseUrl),
+            catch: (cause) => new ReconcileError({ message: "Configured Clockify endpoint is invalid", cause })
+        });
+        if (!["https:", "http:"].includes(endpoint.protocol) || endpoint.username !== "" ||
+            endpoint.password !== "" || endpoint.search !== "" || endpoint.hash !== "")
+            return yield* new ReconcileError({ message: "Configured Clockify endpoint is invalid" });
+        const canonicalEndpoint = `${endpoint.origin}${endpoint.pathname.replace(/\/+$/u, "")}`;
+        const pinnedAuth = { ...auth, baseUrl: canonicalEndpoint };
+        const client = makeClockifyApi(httpClient, pinnedAuth);
+        const user = yield* client.getLoggedUser(undefined).pipe(Effect.mapError((cause) => new ReconcileError({ message: "Cannot verify the Clockify account", cause })));
+        if (user.id === "" || auth.userId !== user.id || auth.workspaceId === "" || auth.baseUrl === "") {
+            return yield* new ReconcileError({ message: "Configured Clockify account does not match the credential" });
+        }
+        return {
+            auth: pinnedAuth,
+            client,
+            scope: JSON.stringify(["clockify-v3", canonicalEndpoint, auth.workspaceId, user.id]),
+            legacyScope: JSON.stringify([auth.workspaceId, user.id])
+        };
+    });
+    /** Bind verification and worklog POST to one OAuth credential and selected site. */
+    const jiraWriteState = Effect.gen(function* () {
+        const login = yield* Effect.result(jiraAuth.isLoggedIn());
+        if (login._tag === "Failure")
+            return { availability: "unverified", snapshot: null };
+        if (!login.success)
+            return { availability: "not-logged-in", snapshot: null };
+        const tokenResult = yield* Effect.result(jiraAuth.getAccessToken());
+        const profileResult = yield* Effect.result(jiraAuth.getActiveProfile());
+        if (tokenResult._tag === "Failure" || profileResult._tag === "Failure") {
+            return { availability: "unverified", snapshot: null };
+        }
+        const token = tokenResult.success;
+        const profile = profileResult.success;
+        if (profile === null || profile.token.cloud_id === "" || profile.token.site_url === "" ||
+            profile.token.access_token !== Redacted.value(token))
+            return { availability: "unverified", snapshot: null };
+        const client = makeJiraApi(httpClient, {
+            baseUrl: "",
+            auth: { type: "oauth2", accessToken: token, cloudId: profile.token.cloud_id }
+        });
+        const live = yield* client.getCurrentUser({}).pipe(Effect.orElseSucceed(() => null));
+        if (live?.accountId === undefined || live.accountId === "") {
+            return { availability: "unverified", snapshot: null };
+        }
+        return {
+            availability: "verified",
+            snapshot: {
+                client,
+                ledgerScope: JSON.stringify([profile.token.cloud_id, live.accountId]),
+                heldScope: JSON.stringify([profile.token.cloud_id, profile.token.site_url, live.accountId]),
+                accountId: live.accountId,
+                cloudId: profile.token.cloud_id,
+                siteUrl: profile.token.site_url
+            }
+        };
+    });
+    const jiraWriteSnapshot = jiraWriteState.pipe(Effect.map((state) => state.snapshot));
+    /**
+     * How many entries to ask Clockify for at a time, and how many pages to accept.
+     *
+     * The page size is explicit because Clockify's own default is 50 — small enough that an ordinary
+     * week silently arrives truncated, and a truncated *recorded* side is the dangerous direction:
+     * every caller subtracts this tally from something and writes the difference, so an entry that
+     * fell off the page reads as time Clockify never had.
+     */
+    const CLOCKIFY_PAGE_SIZE = 200;
+    const CLOCKIFY_MAX_PAGES = 50;
+    // Tally Clockify entries in the period by (ticket, day).
+    const clockifyTally = (period, pinned) => Effect.gen(function* () {
+        const { auth, client } = pinned ?? (yield* clockifyWriteSnapshot);
+        const getPage = (page) => client.getTimeEntries(auth.workspaceId, auth.userId, {
+            params: {
+                start: period.from.toISOString(),
+                end: period.to.toISOString(),
+                page,
+                "page-size": CLOCKIFY_PAGE_SIZE
+            }
         }).pipe(Effect.mapError((e) => new ReconcileError({ message: `Clockify fetch failed: ${e.message}`, cause: e })));
+        const entries = [];
+        let pages = 0;
+        // Stops on an *empty* page rather than a short one. Clockify is free to serve fewer entries
+        // than the page size asked for, and treating a short page as the last one would truncate
+        // exactly as reading a single page did — just less often, and so less visibly.
+        for (; pages < CLOCKIFY_MAX_PAGES; pages++) {
+            const batch = yield* getPage(pages + 1);
+            if (batch.length === 0)
+                break;
+            for (const entry of batch)
+                entries.push(entry);
+        }
+        if (pages === CLOCKIFY_MAX_PAGES) {
+            // Failing costs a run. Proceeding on a partial tally costs someone a duplicated day.
+            return yield* new ReconcileError({
+                message: "Clockify returned more entries than this run will read; narrow the window."
+            });
+        }
         const tally = [];
+        const unlinked = [];
+        const fromMs = period.from.getTime();
+        const toMs = period.to.getTime();
         for (const entry of entries) {
             const ticketKey = parseTicketKey(entry.description);
             const start = entry.timeInterval?.start;
             const end = entry.timeInterval?.end;
-            if (!ticketKey || !start || !end)
-                continue; // skip running / unparseable entries
-            const seconds = Math.max(0, Math.round((new Date(end).getTime() - new Date(start).getTime()) / 1000));
-            tally.push({ ticketKey, day: localDay(new Date(start)), seconds, description: entry.description ?? null });
+            // A missing end is a running timer. A completed entry with missing or malformed bounds
+            // cannot be treated as absent: doing so makes its time look available for another write.
+            if (end === undefined || end === null)
+                continue;
+            if (start === undefined || start === null) {
+                return yield* new ReconcileError({ message: "Clockify returned an incomplete entry" });
+            }
+            const startMs = new Date(start).getTime();
+            const endMs = new Date(end).getTime();
+            if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs <= startMs) {
+                return yield* new ReconcileError({ message: "Clockify returned an incomplete entry" });
+            }
+            if (endMs <= fromMs || startMs >= toMs)
+                continue;
+            for (const bucket of splitIntervalByLocalDay(Math.max(startMs, fromMs), Math.min(Math.max(startMs, endMs), toMs))) {
+                const slice = {
+                    ...bucket,
+                    description: entry.description ?? null,
+                    entry: {
+                        id: entry.id,
+                        source: "clockify",
+                        ticketKey,
+                        startMs,
+                        endMs,
+                        description: entry.description ?? null
+                    }
+                };
+                if (ticketKey === null)
+                    unlinked.push(slice);
+                else
+                    tally.push({ ...slice, ticketKey });
+            }
+        }
+        return { tally, unlinked };
+    });
+    /** Read every Jira page before treating an absent provider ID as deletion evidence. */
+    const readJiraWorklogs = Effect.fn("ReconcileService.readJiraWorklogs")(function* (client, issueKey, startedAfter, startedBefore) {
+        const worklogs = [];
+        const seenIds = new Set();
+        let nextStartAt = 0;
+        let expectedTotal;
+        for (;;) {
+            const page = yield* client.getIssueWorklog(issueKey, {
+                params: { startAt: nextStartAt, startedAfter, startedBefore }
+            }).pipe(Effect.mapError((cause) => new ReconcileError({ message: `Jira worklog fetch failed for ${issueKey}: ${String(cause)}`, cause })));
+            const { maxResults, startAt, total, worklogs: entries } = page;
+            if (startAt !== nextStartAt ||
+                maxResults === undefined || !Number.isSafeInteger(maxResults) || maxResults < 0 ||
+                total === undefined || !Number.isSafeInteger(total) || total < 0 ||
+                entries === undefined || entries.length > maxResults ||
+                (expectedTotal !== undefined && total !== expectedTotal) ||
+                startAt + entries.length > total ||
+                (entries.length === 0 && startAt < total)) {
+                return yield* new ReconcileError({ message: `Jira returned an incomplete worklog page for ${issueKey}` });
+            }
+            expectedTotal = total;
+            for (const entry of entries) {
+                const parsed = toRawWorklog(entry);
+                if (parsed?.id === undefined) {
+                    return yield* new ReconcileError({
+                        message: `Jira returned a worklog without an ID for ${issueKey}; session consumption needs manual review`
+                    });
+                }
+                if (!isReadableWorklog(parsed) ||
+                    !Number.isFinite(new Date(parsed.started).getTime()) ||
+                    seenIds.has(parsed.id)) {
+                    return yield* new ReconcileError({ message: `Jira returned inconsistent worklogs for ${issueKey}` });
+                }
+                seenIds.add(parsed.id);
+                worklogs.push(parsed);
+            }
+            nextStartAt += entries.length;
+            if (nextStartAt === total)
+                return worklogs;
         }
-        return tally;
     });
     // Tally the current user's Jira worklogs in the period by (ticket, day).
-    const jiraTally = (period) => Effect.gen(function* () {
-        const user = yield* jiraAuth.getCurrentUser().pipe(Effect.catch(() => Effect.succeed(null)));
-        const accountId = user?.account_id ?? null;
-        const fromDay = localDay(period.from);
-        const toDay = localDay(period.to);
+    const jiraTally = (period, requiredIssueKeys = [], pinned = undefined) => Effect.gen(function* () {
+        // A verified snapshot pins the account, site and credential-backed client for every page.
+        // Falling back is only for a side without a usable write credential; that side cannot be
+        // written because its source scope remains null, but independent providers may still proceed.
+        const snapshot = pinned === undefined ? yield* jiraWriteSnapshot : pinned;
+        const client = snapshot?.client ?? jira;
+        const cachedAccountId = (yield* jiraAuth.getCurrentUser().pipe(Effect.mapError((cause) => new ReconcileError({ message: "Could not read the Jira account", cause }))))?.account_id;
+        if (snapshot !== null && snapshot !== undefined && cachedAccountId !== snapshot.accountId) {
+            return yield* new ReconcileError({
+                message: "The cached Jira account does not match the verified credential"
+            });
+        }
+        const accountId = snapshot?.accountId ?? cachedAccountId;
+        if (accountId === undefined || accountId === "") {
+            return yield* new ReconcileError({
+                message: "Jira account identity is unavailable; recorded time cannot be tallied"
+            });
+        }
+        const fromMs = period.from.getTime();
+        const from = period.from;
+        // Jira indexes a worklog by its start day. Include the prior local day so an overnight
+        // worklog can contribute the slice that overlaps this period's first day.
+        const lookupFromMs = new Date(from.getFullYear(), from.getMonth(), from.getDate() - 1).getTime();
+        const fromDay = localDay(new Date(lookupFromMs));
+        // `period.to` is exclusive and `worklogDate <=` is not, so the last *included* instant is
+        // what names the day. Taking the endpoint's own day asked Jira for the next day's issues as
+        // well — harmless in the tally, which filters by instant, but every extra issue is another
+        // worklog request, and one failure there fails the whole run by design.
+        const toDay = localDay(new Date(Math.max(period.from.getTime(), period.to.getTime() - 1)));
         // Find issues the user logged work on in the window.
-        const search = yield* jira.searchIssuesUsingJql({
+        // Every page, not just the first. A ticket that fell off page one tallies as zero Jira time,
+        // and since every caller subtracts this from what a session accounts for, that reads as
+        // "Jira is short by the whole day" — which `watch` would then post on top of hours Jira
+        // already holds. A window of more than a hundred distinct issues is an ordinary week.
+        const jql = `worklogAuthor = currentUser() AND worklogDate >= "${fromDay}" AND worklogDate <= "${toDay}"`;
+        const searchPage = (pageToken) => client.searchIssuesUsingJql({
             params: {
-                jql: `worklogAuthor = currentUser() AND worklogDate >= "${fromDay}" AND worklogDate <= "${toDay}"`,
+                jql,
                 maxResults: 100,
-                fields: ["key"]
+                fields: ["key"],
+                ...((pageToken !== undefined) && { nextPageToken: pageToken })
             }
         }).pipe(Effect.mapError((e) => new ReconcileError({ message: `Jira search failed: ${String(e)}`, cause: e })));
-        const issueKeys = (search.issues ?? []).flatMap((issue) => {
+        const searched = [];
+        let pageToken = undefined;
+        // Bounded so a server that keeps handing back a token cannot spin here for ever; hitting the
+        // bound fails the run rather than proceeding on a partial tally.
+        for (let page = 0; page < 50; page++) {
+            const result = yield* searchPage(pageToken);
+            const issues = Predicate.isObject(result) ? result["issues"] : undefined;
+            // A page with no `issues` at all is not an empty page. The generated success schema makes
+            // the field optional, so a response Jira truncated or a shape that changed under us would
+            // otherwise read as "this user logged no work" — and every caller subtracts that from what
+            // a session accounts for before writing the difference.
+            if (!Array.isArray(issues)) {
+                return yield* new ReconcileError({
+                    message: "Jira returned a worklog search page with no issues field; not tallying a partial result."
+                });
+            }
+            for (const issue of issues)
+                searched.push(issue);
+            const next = Predicate.isObject(result) && Predicate.isString(result["nextPageToken"])
+                ? result["nextPageToken"]
+                : undefined;
+            if (Predicate.isObject(result) && result["isLast"] === false && (next === undefined || next.trim() === "")) {
+                return yield* new ReconcileError({ message: "Jira returned an incomplete Jira search page" });
+            }
+            pageToken = next;
+            if (next === undefined)
+                break;
+        }
+        if (pageToken !== undefined) {
+            return yield* new ReconcileError({
+                message: "Jira returned more worklog pages than this run will read; narrow the window."
+            });
+        }
+        // An issue whose key cannot be read is an issue whose worklogs go unread, which is the same
+        // under-count as a dropped page — so it fails rather than being skipped.
+        const issueKeys = [];
+        for (const issue of searched) {
             const key = issueKey(issue);
-            return key ? [key] : [];
-        });
-        const fromMs = period.from.getTime();
+            if (key === null) {
+                return yield* new ReconcileError({
+                    message: "Jira returned a worklog search result with no issue key; not tallying a partial result."
+                });
+            }
+            issueKeys.push(key);
+        }
+        for (const key of requiredIssueKeys) {
+            if (!issueKeys.includes(key))
+                issueKeys.push(key);
+        }
         const toMs = period.to.getTime();
         const tally = [];
         for (const issueKey of issueKeys) {
-            const worklogs = yield* jira.getIssueWorklog(issueKey, {
-                params: {
-                    startedAfter: fromMs,
-                    startedBefore: toMs
-                }
-            }).pipe(Effect.map(toRawWorklogs), Effect.catch(() => Effect.succeed([])));
+            const worklogs = yield* readJiraWorklogs(client, issueKey, lookupFromMs - 1, toMs);
             for (const wl of worklogs) {
-                if (!wl.started || !Predicate.isNumber(wl.timeSpentSeconds))
-                    continue;
                 // Only this user's worklogs (the JQL narrows issues, not individual worklog authors).
-                if (accountId && wl.author?.accountId && wl.author.accountId !== accountId)
+                const author = wl.author?.accountId;
+                if (author !== accountId)
                     continue;
                 const startedMs = new Date(wl.started).getTime();
-                if (startedMs < fromMs || startedMs >= toMs)
+                const endedMs = startedMs + wl.timeSpentSeconds * 1000;
+                if (endedMs <= fromMs || startedMs >= toMs)
                     continue;
-                tally.push({ ticketKey: issueKey, day: localDay(new Date(wl.started)), seconds: wl.timeSpentSeconds });
+                const entry = wl.id === undefined
+                    ? undefined
+                    : {
+                        id: wl.id,
+                        source: "jira",
+                        ticketKey: issueKey,
+                        startMs: startedMs,
+                        endMs: endedMs,
+                        description: yield* Schema.decodeUnknownEffect(Schema.UndefinedOr(Schema.Json))(wl.comment).pipe(Effect.flatMap(jiraWorklogDescription), Effect.mapError((cause) => new ReconcileError({ message: cause.message, cause })))
+                    };
+                // Clockify and session evidence use local calendar slices. Apply the same accounting
+                // policy to Jira's duration even though Jira stores it as one start-day worklog, or a
+                // matching overnight pair becomes two opposite discrepancies.
+                for (const bucket of splitIntervalByLocalDay(Math.max(startedMs, fromMs), Math.min(endedMs, toMs))) {
+                    tally.push({
+                        ticketKey: issueKey,
+                        ...(entry !== undefined && { entry }),
+                        ...bucket
+                    });
+                }
             }
         }
         return tally;
     });
-    const compare = (period) => Effect.gen(function* () {
-        const [clockifySide, jiraSide] = yield* Effect.all([clockifyTally(period), jiraTally(period)], {
-            concurrency: 2
+    const readRecorded = (period, options) => Effect.gen(function* () {
+        const sides = options?.sides ?? bothSides;
+        // A side that is out is not called at all. That is the point of the option for someone who
+        // tracks in one system: no Clockify workspace to configure, no Jira login to keep alive, and
+        // no request whose failure could stop a run that never needed it.
+        const jiraSideRead = sides.jira
+            ? jiraTally(period, options?.jiraIssueKeys, options?.jiraSnapshot)
+            : Effect.succeed([]);
+        const [clockifySide, jiraSide] = yield* Effect.all([
+            sides.clockify
+                ? clockifyTally(period, options?.clockifySnapshot)
+                : Effect.succeed({ tally: [], unlinked: [] }),
+            options?.tolerateUnavailableJira === true
+                ? jiraSideRead.pipe(Effect.catch(() => Effect.succeed([])))
+                : jiraSideRead
+        ], { concurrency: 2 });
+        return { recorded: buildReconcileRows(clockifySide.tally, jiraSide), unlinkedClockify: clockifySide.unlinked };
+    });
+    const compare = (period, options) => readRecorded(period, options).pipe(Effect.map((result) => result.recorded));
+    /**
+     * Read one bound Clockify entry without the generated client's lossy unexpected-status fallback.
+     *
+     * Clockify's pinned OpenAPI contract declares no typed not-found response for this operation.
+     * A non-2xx response therefore remains uncertain even when its numeric status is 404.
+     */
+    const readClockifyBinding = (binding, snapshot) => snapshot.client.httpClient.execute(HttpClientRequest.get(`/v1/workspaces/${snapshot.auth.workspaceId}/time-entries/${binding.entryId}`).pipe(HttpClientRequest.setUrlParam("hydrated", "false"))).pipe(Effect.flatMap((response) => response.status >= 200 && response.status < 300
+        ? HttpClientResponse.schemaBodyJson(ClockifyApi.GetTimeEntry200)(response).pipe(Effect.mapError((cause) => new ReconcileError({ message: "Clockify returned incomplete bound-entry evidence", cause })))
+        : Effect.fail(new ReconcileError({ message: "Clockify did not provide a verifiable bound-entry response" }))), Effect.mapError((cause) => Predicate.isTagged(cause, "ReconcileError")
+        ? cause
+        : new ReconcileError({ message: "Could not verify the current Clockify bound entry", cause })));
+    /** A targeted read can verify presence; ambiguous misses keep the bound credit held. */
+    const readBindingEvidence = (binding, currentEntries, clockifySnapshot, jiraSnapshot) => {
+        const current = currentEntries.find((entry) => entry.source === binding.provider && entry.id === binding.entryId);
+        if (current !== undefined)
+            return Effect.succeed({ _tag: "Present", entry: current });
+        const read = binding.provider === "clockify"
+            ? readClockifyBinding(binding, clockifySnapshot).pipe(Effect.flatMap((entry) => {
+                const start = entry.timeInterval.start;
+                const end = entry.timeInterval.end;
+                const startMs = new Date(start ?? "").getTime();
+                const endMs = new Date(end ?? "").getTime();
+                if (entry.id !== binding.entryId || entry.userId !== clockifySnapshot.auth.userId ||
+                    entry.workspaceId !== clockifySnapshot.auth.workspaceId || end === undefined ||
+                    !Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs <= startMs) {
+                    return Effect.fail(new ReconcileError({
+                        message: "Clockify returned incomplete bound-entry evidence"
+                    }));
+                }
+                return Effect.succeed({
+                    _tag: "Present",
+                    entry: {
+                        id: entry.id,
+                        source: "clockify",
+                        ticketKey: parseTicketKey(entry.description),
+                        startMs,
+                        endMs,
+                        description: entry.description
+                    }
+                });
+            }))
+            : jiraSnapshot.client.getWorklog(binding.ticketKey, binding.entryId, undefined).pipe(Effect.flatMap((value) => {
+                const worklog = toRawWorklog(value);
+                if (worklog === null || !isReadableWorklog(worklog) || worklog.id !== binding.entryId ||
+                    worklog.author.accountId !== jiraSnapshot.accountId) {
+                    return Effect.fail(new ReconcileError({ message: "Jira returned incomplete bound-worklog evidence" }));
+                }
+                const startMs = new Date(worklog.started).getTime();
+                const endMs = startMs + worklog.timeSpentSeconds * 1000;
+                if (!Number.isFinite(startMs) || endMs <= startMs) {
+                    return Effect.fail(new ReconcileError({ message: "Jira returned incomplete bound-worklog evidence" }));
+                }
+                return Effect.succeed({
+                    _tag: "Present",
+                    entry: {
+                        id: worklog.id,
+                        source: "jira",
+                        ticketKey: binding.ticketKey,
+                        startMs,
+                        endMs,
+                        description: null
+                    }
+                });
+            }), Effect.catchTag("GetWorklog404", () => Effect.gen(function* () {
+                if (binding.jiraCreatedAtMs === undefined) {
+                    return yield* new ReconcileError({
+                        message: "Jira bound entry has no provider-created checkpoint; deletion remains unproved"
+                    });
+                }
+                const evidence = yield* readJiraDeletionEvidence(jiraSnapshot.client, binding.entryId, binding.jiraCreatedAtMs).pipe(Effect.mapError((cause) => new ReconcileError({ message: cause.message })));
+                if (evidence._tag === "Unproved") {
+                    return yield* new ReconcileError({ message: "Jira bound entry has no verified deletion event" });
+                }
+                const current = yield* jiraWriteState;
+                if (current.snapshot === null || current.snapshot.heldScope !== jiraSnapshot.heldScope) {
+                    return yield* new ReconcileError({ message: "Jira account changed during deletion verification" });
+                }
+                // A deletion event is historical. Jira's targeted 404 also covers lost visibility,
+                // so neither fact proves the entry is still absent after an out-of-band restore.
+                return yield* new ReconcileError({
+                    message: "Jira deleted-worklog event is verified, but current absence is not"
+                });
+            })));
+        return read.pipe(Effect.mapError((cause) => new ReconcileError({ message: `Could not verify the current ${binding.provider} bound entry`, cause })));
+    };
+    const directionSource = (recorded, unlinkedClockify, clockifySnapshot, jiraSnapshot) => (row, direction, seconds) => Effect.gen(function* () {
+        const sourceProvider = direction === "clockify-to-jira" ? "clockify" : "jira";
+        const targetProvider = sourceProvider === "clockify" ? "jira" : "clockify";
+        const sourceEntries = row.intervals
+            .flatMap(({ entry }) => entry?.source === sourceProvider ? [entry] : [])
+            .filter((entry, index, entries) => entries.findIndex((candidate) => candidate.id === entry.id) === index);
+        const stored = yield* sourceLedger.read.pipe(Effect.mapError((cause) => new ReconcileError({ message: cause.message, cause })));
+        const hasMarker = sourceEntries.some((entry) => entry.description !== null && SourceConsumption.markers(entry.description).length > 0);
+        const mayBeBound = sourceEntries.some((entry) => stored.bindings.some((binding) => binding.provider === sourceProvider && binding.entryId === entry.id));
+        if (!hasMarker && !mayBeBound)
+            return { _tag: "Ordinary" };
+        if (jiraSnapshot === null) {
+            return {
+                _tag: "Refused",
+                message: "Direction provenance could not be verified for the current provider accounts"
+            };
+        }
+        const sourceScope = sourceProvider === "clockify" ? clockifySnapshot.scope : jiraSnapshot.ledgerScope;
+        const targetScope = targetProvider === "clockify" ? clockifySnapshot.scope : jiraSnapshot.ledgerScope;
+        const expectedTargetScope = targetProvider === "clockify" ? clockifySnapshot.scope : jiraSnapshot.heldScope;
+        const expectedSourceScope = sourceProvider === "clockify" ? clockifySnapshot.scope : jiraSnapshot.heldScope;
+        const sourceIds = new Set(sourceEntries.map((entry) => entry.id));
+        const verifiedSource = stored.bindings.filter((binding) => binding.provider === sourceProvider && binding.scope === sourceScope && sourceIds.has(binding.entryId));
+        if (verifiedSource.length === 0 ||
+            sourceEntries.some((entry) => entry.description !== null && SourceConsumption.markers(entry.description).length > 0 &&
+                !verifiedSource.some((binding) => binding.entryId === entry.id))) {
+            return { _tag: "Refused", message: "Direction source marker is not verified by the private ledger" };
+        }
+        const sourceKeys = new Map(verifiedSource.map((binding) => [
+            SourceConsumption.blockKey(binding.rowId, binding.sourceStartMs),
+            { rowId: binding.rowId, sourceStartMs: binding.sourceStartMs }
+        ]));
+        if (sourceKeys.size !== 1) {
+            return {
+                _tag: "Refused",
+                message: "Direction row combines more than one verified source block; split it manually before writing"
+            };
+        }
+        const sourceKey = sourceKeys.values().next().value;
+        if (sourceKey === undefined) {
+            return { _tag: "Refused", message: "Direction source binding is unavailable" };
+        }
+        const currentEntries = [
+            ...recorded.flatMap((candidate) => candidate.intervals.flatMap(({ entry }) => entry === undefined ? [] : [entry])),
+            ...unlinkedClockify.flatMap(({ entry }) => entry === undefined ? [] : [entry])
+        ].filter((entry, index, entries) => entries.findIndex((candidate) => candidate.source === entry.source && candidate.id === entry.id) === index);
+        const sourceEvidence = yield* Effect.forEach(verifiedSource, (binding) => readBindingEvidence(binding, currentEntries, clockifySnapshot, jiraSnapshot), { concurrency: 2 });
+        const sourceIntervals = verifiedSource.flatMap((binding, index) => {
+            const evidence = sourceEvidence[index];
+            if (evidence?._tag !== "Present")
+                return [];
+            const startMs = Math.max(binding.startMs, evidence.entry.startMs);
+            const endMs = Math.min(binding.endMs, evidence.entry.endMs);
+            return endMs > startMs ? [{ startMs, endMs }] : [];
         });
-        return buildReconcileRows(clockifySide, jiraSide);
+        const sourceAuthority = mergeIntervals(sourceIntervals);
+        if (sourceAuthority.length !== 1 || sourceIntervals.length !== verifiedSource.length) {
+            return {
+                _tag: "Refused",
+                message: "Direction source intervals are no longer one contiguous verified block"
+            };
+        }
+        const sourceInterval = sourceAuthority[0];
+        if (sourceInterval === undefined) {
+            return { _tag: "Refused", message: "Direction source interval is unavailable" };
+        }
+        const targetBindings = stored.bindings.filter((binding) => binding.provider === targetProvider && binding.scope === targetScope &&
+            binding.rowId === sourceKey.rowId && binding.sourceStartMs === sourceKey.sourceStartMs);
+        const targetEvidence = yield* Effect.forEach(targetBindings, (binding) => readBindingEvidence(binding, currentEntries, clockifySnapshot, jiraSnapshot), { concurrency: 2 });
+        const consumedIntervals = targetBindings.flatMap((_binding, index) => {
+            const evidence = targetEvidence[index];
+            return evidence?._tag === "Present"
+                ? [{ startMs: evidence.entry.startMs, endMs: evidence.entry.endMs }]
+                : [];
+        });
+        if (consumedIntervals.some((interval) => interval.startMs < sourceInterval.startMs || interval.endMs > sourceInterval.endMs)) {
+            return {
+                _tag: "Refused",
+                message: "A bound target moved outside its verified source interval"
+            };
+        }
+        const remaining = subtractIntervals(sourceInterval, consumedIntervals);
+        if (remaining.length === 0 || seconds <= 0) {
+            return { _tag: "Refused", message: "Direction delta exceeds the remaining verified source time" };
+        }
+        if (remaining.length !== 1) {
+            return {
+                _tag: "Refused",
+                message: "Verified target time leaves disconnected source intervals; split it manually before writing"
+            };
+        }
+        const remainingInterval = remaining[0];
+        if (remainingInterval === undefined) {
+            return { _tag: "Refused", message: "Direction source interval is unavailable" };
+        }
+        const remainingSeconds = (remainingInterval.endMs - remainingInterval.startMs) / 1000;
+        const writableSeconds = Math.min(seconds, remainingSeconds);
+        if (!Number.isSafeInteger(writableSeconds) || writableSeconds <= 0) {
+            return { _tag: "Refused", message: "Direction remainder is not representable as whole seconds" };
+        }
+        if (targetProvider === "jira" && writableSeconds < MINIMUM_PROPOSAL_SECONDS) {
+            return { _tag: "Refused", message: "Direction remainder is less than Jira's one-minute minimum" };
+        }
+        const startedAtMs = remainingInterval.startMs;
+        return {
+            _tag: "Bound",
+            startedAt: new Date(startedAtMs),
+            source: {
+                rowId: sourceKey.rowId,
+                sourceStartMs: sourceKey.sourceStartMs,
+                startMs: startedAtMs,
+                endMs: startedAtMs + writableSeconds * 1000,
+                seconds: writableSeconds,
+                expectedScope: expectedTargetScope,
+                expectedSource: { provider: sourceProvider, scope: expectedSourceScope }
+            }
+        };
     });
-    // Noon-local on the bucket's day — keeps the worklog/entry firmly on that calendar day.
+    const compareDirection = (period) => Effect.gen(function* () {
+        const clockifySnapshot = yield* clockifyWriteSnapshot;
+        const jiraSnapshot = (yield* jiraWriteState).snapshot;
+        const result = yield* readRecorded(period, { clockifySnapshot, jiraSnapshot });
+        return {
+            rows: result.recorded,
+            resolveSource: directionSource(result.recorded, result.unlinkedClockify, clockifySnapshot, jiraSnapshot)
+        };
+    });
+    // Noon-local on the bucket's day — the fallback when a caller knows only the day. It keeps the
+    // worklog or entry firmly on the right calendar day whatever the reader's timezone.
     const dayStart = (day) => new Date(`${day}T12:00:00`);
-    const applyToJira = (ticketKey, day, seconds, comment) => timer.logWorklog({
-        ticketKey,
-        startedAt: dayStart(day),
-        durationSeconds: seconds,
-        // Carry the Clockify description across; only fall back to a generic note when blank.
-        comment: comment && comment.trim() ? comment.trim() : "Reconciled from Clockify"
+    /**
+     * When the work began: the caller's instant if it belongs to this day, else local noon.
+     *
+     * The day check matters because the bucket's day is authoritative — a caller must not be able to
+     * push an entry onto a neighbouring day by passing an instant from it.
+     */
+    const startOf = (day, startedAt) => startedAt !== undefined && localDay(startedAt) === day ? startedAt : dayStart(day);
+    const sourceScopeIsCurrent = (source) => {
+        if (source?.expectedSource === undefined)
+            return Effect.succeed(true);
+        if (source.expectedSource.provider === "clockify") {
+            return Effect.result(clockifyWriteSnapshot).pipe(Effect.map((result) => result._tag === "Success" && result.success.scope === source.expectedSource?.scope));
+        }
+        return jiraWriteState.pipe(Effect.map((state) => state.snapshot?.heldScope === source.expectedSource?.scope));
+    };
+    const applyToJiraUnGuarded = (ticketKey, day, seconds, comment, startedAt, source) => Effect.gen(function* () {
+        if (source !== undefined &&
+            (seconds !== source.seconds || startedAt?.getTime() !== source.startMs)) {
+            return { _tag: "Failed", message: "The approved Jira interval changed before confirmation" };
+        }
+        if (!(yield* sourceScopeIsCurrent(source))) {
+            return { _tag: "Failed", message: "The source provider account changed since this direction was read" };
+        }
+        const state = source === undefined ? undefined : yield* jiraWriteState;
+        const snapshot = state?.snapshot ?? null;
+        const identity = source === undefined || snapshot === null ? undefined : {
+            rowId: source.rowId,
+            sourceStartMs: source.sourceStartMs,
+            startMs: source.startMs,
+            endMs: source.endMs,
+            seconds: source.seconds,
+            ticketKey,
+            provider: "jira",
+            scope: snapshot.ledgerScope
+        };
+        if (source !== undefined && identity === undefined) {
+            return state?.availability === "not-logged-in"
+                ? { _tag: "NotLoggedIn" }
+                : { _tag: "VerificationUnavailable" };
+        }
+        if (source?.expectedScope !== undefined && snapshot?.heldScope !== source.expectedScope) {
+            return { _tag: "Failed", message: "The Jira account changed since this plan was read" };
+        }
+        if (identity !== undefined) {
+            const reserved = yield* Effect.result(sourceLedger.reserve(identity));
+            if (reserved._tag === "Failure")
+                return { _tag: "Failed", message: reserved.failure.message };
+        }
+        let writeSnapshot = snapshot;
+        if (identity !== undefined) {
+            const sourceIsCurrent = yield* sourceScopeIsCurrent(source);
+            const currentState = yield* jiraWriteState;
+            const current = currentState.snapshot;
+            if (!sourceIsCurrent || current === null || current.ledgerScope !== identity.scope ||
+                source?.expectedScope !== undefined && current.heldScope !== source.expectedScope) {
+                const released = yield* Effect.result(sourceLedger.release(identity));
+                if (released._tag === "Failure") {
+                    return {
+                        _tag: "Failed",
+                        message: "Provider identity changed and the private write intent needs manual review"
+                    };
+                }
+                if (!sourceIsCurrent) {
+                    return { _tag: "Failed", message: "The source provider account changed before the Jira worklog write" };
+                }
+                if (currentState.availability === "not-logged-in")
+                    return { _tag: "NotLoggedIn" };
+                if (currentState.availability === "unverified")
+                    return { _tag: "VerificationUnavailable" };
+                return { _tag: "Failed", message: "The Jira account changed before the worklog write" };
+            }
+            writeSnapshot = current;
+        }
+        const params = {
+            ticketKey,
+            startedAt: startOf(day, startedAt),
+            durationSeconds: seconds,
+            comment: comment !== undefined && comment.trim() !== "" ? comment.trim() : "Reconciled from Clockify"
+        };
+        const posted = writeSnapshot === null
+            ? yield* timer.logWorklog(params)
+            : yield* postJiraWorklog(writeSnapshot.client, params);
+        if (identity === undefined)
+            return posted;
+        if (posted._tag === "NotLoggedIn") {
+            const released = yield* Effect.result(sourceLedger.release(identity));
+            return released._tag === "Failure"
+                ? { _tag: "Failed", message: "Jira was not called but the private write intent could not be released" }
+                : posted;
+        }
+        if (posted._tag !== "Posted")
+            return posted;
+        if (posted.entryId === undefined || posted.entryId === "") {
+            return {
+                _tag: "Failed",
+                message: "Jira may have written time without returning an entry ID; manual recovery required"
+            };
+        }
+        // An exact provider read may add a Jira-clock checkpoint; its failure cannot undo a confirmed POST.
+        const createdAtMs = writeSnapshot === null
+            ? undefined
+            : yield* writeSnapshot.client.getWorklog(ticketKey, posted.entryId, undefined).pipe(Effect.flatMap((worklog) => {
+                const value = worklog.created === undefined ? NaN : new Date(worklog.created).getTime();
+                const valid = worklog.id === posted.entryId &&
+                    worklog.author?.accountId === writeSnapshot.accountId &&
+                    Number.isSafeInteger(value) && value >= 0;
+                return valid
+                    ? Effect.succeed(value)
+                    : Effect.logWarning("Jira creation checkpoint is incomplete; deletion reconciliation stays held")
+                        .pipe(Effect.as(undefined));
+            }), Effect.catch(() => Effect.logWarning("Jira creation checkpoint is unavailable; deletion reconciliation stays held")
+                .pipe(Effect.as(undefined))));
+        const bound = yield* Effect.result(sourceLedger.bind(identity, posted.entryId, createdAtMs));
+        return bound._tag === "Failure"
+            ? { _tag: "Failed", message: "Jira wrote time but its private binding failed; manual recovery required" }
+            : posted;
     });
-    const applyToClockify = (ticketKey, day, seconds) => Effect.gen(function* () {
-        const auth = yield* getAuth;
+    const applyToJira = (ticketKey, day, seconds, comment, startedAt, source) => provideGuard(WriterGuard.mutate(applyToJiraUnGuarded(ticketKey, day, seconds, comment, startedAt, source))).pipe(Effect.catchTag("WriterGuardError", (error) => Effect.succeed({ _tag: "Failed", message: error.message })));
+    const applyToClockifyUnGuarded = (ticketKey, day, seconds, note, startedAt, source) => Effect.gen(function* () {
+        if (source !== undefined &&
+            (seconds !== source.seconds || startedAt?.getTime() !== source.startMs)) {
+            return yield* new ReconcileError({ message: "The approved Clockify interval changed before confirmation" });
+        }
+        if (!(yield* sourceScopeIsCurrent(source))) {
+            return yield* new ReconcileError({
+                message: "The source provider account changed since this direction was read"
+            });
+        }
+        const snapshot = yield* clockifyWriteSnapshot;
         const cfg = yield* config.get;
-        const start = dayStart(day);
+        const start = startOf(day, startedAt);
         const end = new Date(start.getTime() + seconds * 1000);
-        yield* clockify.createTimeEntry(auth.workspaceId, {
-            description: `[${ticketKey}] Reconciled from Jira`,
-            start: start.toISOString(),
-            end: end.toISOString(),
-            ...((cfg.defaultProjectId) && { projectId: cfg.defaultProjectId })
+        const identity = source === undefined ? undefined : {
+            rowId: source.rowId,
+            sourceStartMs: source.sourceStartMs,
+            startMs: source.startMs,
+            endMs: source.endMs,
+            seconds: source.seconds,
+            provider: "clockify",
+            scope: snapshot.scope,
+            ticketKey
+        };
+        if (source?.expectedScope !== undefined && identity?.scope !== source.expectedScope) {
+            return yield* new ReconcileError({ message: "The Clockify account changed since this plan was read" });
+        }
+        if (identity !== undefined) {
+            yield* sourceLedger.reserve(identity, snapshot.legacyScope).pipe(Effect.mapError((cause) => new ReconcileError({ message: cause.message, cause })));
+        }
+        const sourceIsCurrent = yield* sourceScopeIsCurrent(source);
+        const verified = yield* Effect.result(clockifyWriteSnapshot);
+        if (!sourceIsCurrent || verified._tag === "Failure") {
+            if (identity !== undefined) {
+                const released = yield* Effect.result(sourceLedger.release(identity));
+                if (released._tag === "Failure") {
+                    return yield* new ReconcileError({
+                        message: "Clockify was not called but its private write intent needs manual recovery",
+                        cause: released.failure
+                    });
+                }
+            }
+            return yield* verified._tag === "Failure"
+                ? verified.failure
+                : new ReconcileError({ message: "The source provider account changed before the Clockify write" });
+        }
+        const current = verified.success;
+        if (current.scope !== snapshot.scope ||
+            (source?.expectedScope !== undefined && current.scope !== source.expectedScope)) {
+            if (identity !== undefined) {
+                yield* sourceLedger.release(identity).pipe(Effect.mapError((cause) => new ReconcileError({ message: cause.message, cause })));
+            }
+            return yield* new ReconcileError({ message: "The Clockify account changed before the write" });
+        }
+        const created = yield* current.client.createTimeEntry(current.auth.workspaceId, {
+            payload: {
+                description: `[${ticketKey}] ${note !== undefined && note.trim() !== "" ? note.trim() : "Reconciled from Jira"}`,
+                start: start.toISOString(),
+                end: end.toISOString(),
+                // Stated, not left to Clockify's own default. `jcf timer start` already sends it, so
+                // omitting it here made a reconciled entry's billable flag differ from a timed one's for
+                // the same ticket — visible only later, on an invoice.
+                billable: cfg.defaultBillable,
+                ...((cfg.defaultProjectId) && { projectId: cfg.defaultProjectId })
+            }
         }).pipe(Effect.mapError((e) => new ReconcileError({ message: `Clockify create failed: ${e.message}`, cause: e })));
+        if (identity !== undefined) {
+            yield* sourceLedger.bind(identity, created.id).pipe(Effect.mapError((cause) => new ReconcileError({
+                message: "Clockify wrote time but its private binding failed; manual recovery required",
+                cause
+            })));
+        }
         return true;
     });
-    return { compare, applyToJira, applyToClockify };
+    const applyToClockify = (ticketKey, day, seconds, note, startedAt, source) => provideGuard(WriterGuard.mutate(applyToClockifyUnGuarded(ticketKey, day, seconds, note, startedAt, source))).pipe(Effect.mapError((error) => error._tag === "WriterGuardError"
+        ? new ReconcileError({ message: error.message, cause: error })
+        : error));
+    /**
+     * Days that must not be proposed because a Timer is still running across them.
+     *
+     * Load-bearing, not politeness: a running Clockify entry has no end time, and the Clockify
+     * tally skips entries without one. Its time is therefore invisible to the subtraction, so
+     * proposing such a day would log hours a second time the moment the Timer is stopped.
+     *
+     * Every day the Timer spans is excluded, not just the one it started on. A Timer left running
+     * overnight hides time on each day it crosses, and the day it happened to start is no safer than
+     * the others — it is simply the one a shorter rule noticed.
+     */
+    const runningTimerExclusions = (period, snapshot) => Effect.gen(function* () {
+        // Fails the run rather than logging and carrying on. An unknown running-timer state is not
+        // an absent one, and every caller of this subtracts before writing the difference.
+        const running = yield* snapshot.client.getTimeEntries(snapshot.auth.workspaceId, snapshot.auth.userId, {
+            params: { "in-progress": "true", "page-size": 1 }
+        }).pipe(Effect.mapError((cause) => new ReconcileError({ message: "Could not rule out a running timer", cause })));
+        if (running.length === 0)
+            return [];
+        const started = running[0]?.timeInterval.start;
+        const startedMs = started === undefined ? Number.NaN : new Date(started).getTime();
+        if (!Number.isFinite(startedMs)) {
+            return yield* new ReconcileError({ message: "Running Clockify timer has no valid start" });
+        }
+        // Clamped to the window on both sides: a Timer running since last week makes nothing outside
+        // this period any less proposable, and the period's own end is as far as the run can look.
+        const fromMs = Math.max(startedMs, period.from.getTime());
+        const toMs = period.to.getTime() - 1;
+        if (fromMs > toMs)
+            return [];
+        const excluded = [];
+        for (let cursor = fromMs; cursor <= toMs; cursor = nextLocalMidnight(cursor)) {
+            excluded.push({
+                day: localDay(new Date(cursor)),
+                reason: "a Clockify timer is still running on this day — stop it and re-run"
+            });
+        }
+        return excluded;
+    });
+    /**
+     * Attribute every session, spending a Coding Agent call only where the deterministic signals
+     * came up empty.
+     *
+     * The calls run concurrently. They are the slowest thing this command does — a CLI process
+     * each, tens of seconds apiece — and doing them one after another is what makes a week's run
+     * look like it has hung. A failure marks the Coding Agent unavailable so the remaining
+     * sessions are honestly reported as Unattributed Sessions rather than retried.
+     */
+    const attributeSessions = (sessions, options) => Effect.gen(function* () {
+        // `deterministicAttribution` is asked here purely to decide whether a call is warranted;
+        // `attributeSession` remains the single place the precedence is actually applied.
+        const needsAgent = options.mode === "deterministic" ?
+            [] :
+            sessions.filter((session) => deterministicAttribution(session, { standingMap: options.standingMap }) === null &&
+                session.candidateKeys.length > 0);
+        const batches = batchRequests(needsAgent);
+        if (needsAgent.length > 0) {
+            yield* options.onProgress({
+                _tag: "AttributingSessions",
+                count: needsAgent.length,
+                calls: batches.length
+            });
+        }
+        // Counted as batches finish rather than in list order, so the reported number always
+        // reflects work actually completed. Safe as a plain counter: Effect's scheduler runs these
+        // fibers on one thread, so the increment cannot interleave.
+        let done = 0;
+        const batchResults = yield* Effect.all(batches.map((batch, batchIndex) => attributor.attribute(batch.map((session) => ({
+            sessionId: session.sessionId,
+            candidateKeys: session.candidateKeys,
+            digest: session.digest
+        })), (activity) => options.onProgress({
+            _tag: "AgentActivity",
+            batch: batchIndex + 1,
+            batches: batches.length,
+            ...activity
+        })).pipe(Effect.map((answers) => {
+            const bySession = new Map(answers.map((answer) => [answer.sessionId, answer.choice]));
+            return batch.map((session) => {
+                const declined = { _tag: "None" };
+                const choice = bySession.get(session.sessionId) ?? declined;
+                return {
+                    session,
+                    choice,
+                    outcome: (choice._tag === "Chosen"
+                        ? { _tag: "Placed", ticketKey: choice.ticketKey, confidence: choice.confidence }
+                        : { _tag: "Declined" })
+                };
+            });
+        }), 
+        // No log here: the failure is reported to the progress listener below, which puts it
+        // on stderr with the sessions it belongs to. Logging as well printed it twice.
+        //
+        // A failed call costs every session in its batch, which is why batches are bounded.
+        Effect.catch((error) => Effect.succeed(batch.map((session) => ({
+            session,
+            choice: null,
+            outcome: { _tag: "Unavailable", message: error.message }
+        })))), Effect.tap((results) => Effect.forEach(results, (result) => {
+            done += 1;
+            return options.onProgress({
+                _tag: "SessionAttributed",
+                done,
+                total: needsAgent.length,
+                gitBranch: result.session.gitBranch,
+                cwd: result.session.cwd,
+                outcome: result.outcome
+            });
+        }, { discard: true })))), { concurrency: ATTRIBUTOR_CONCURRENCY });
+        const answers = batchResults.flat();
+        if (needsAgent.length > 0) {
+            yield* options.onProgress({
+                _tag: "SessionsAttributed",
+                placed: answers.filter((answer) => answer.outcome._tag === "Placed").length,
+                declined: answers.filter((answer) => answer.outcome._tag === "Declined").length,
+                unavailable: answers.filter((answer) => answer.outcome._tag === "Unavailable").length
+            });
+        }
+        const chosen = new Map();
+        let attributorAvailable = true;
+        for (const answer of answers) {
+            if (answer.choice === null) {
+                attributorAvailable = false;
+                continue;
+            }
+            if (answer.choice._tag === "Chosen") {
+                chosen.set(answer.session.sessionId, {
+                    ticketKey: answer.choice.ticketKey,
+                    confidence: answer.choice.confidence
+                });
+            }
+        }
+        const attributions = sessions.map((session) => attributeSession(session, {
+            standingMap: options.standingMap,
+            agentChoice: chosen.get(session.sessionId) ?? null,
+            confidenceFloor: options.confidenceFloor
+        }));
+        return { attributions, attributorAvailable, attributorCalls: batches.length };
+    });
+    const describeProposals = (options) => Effect.gen(function* () {
+        if (options.proposals.length === 0)
+            return [];
+        const requests = options.proposals.map((proposal, index) => ({
+            id: String(index),
+            ticketKey: proposal.ticketKey,
+            summary: options.summaries?.get(proposal.ticketKey) ?? null,
+            digest: bucketDigest(proposal, options.digests)
+        }));
+        // Batched on the same budget as attribution: the prompt carries whole digests, so the bound
+        // that matters is characters, not rows.
+        const batches = batchRequests(requests);
+        const answers = yield* Effect.forEach(batches, (batch) => attributor.describe(batch).pipe(
+        // A batch that fails costs its own notes and nothing else. Reported as a warning
+        // rather than a failure: the worklog it belongs to is still correct without a sentence.
+        Effect.catch((error) => (options.onUnavailable?.(error.message) ?? Effect.void).pipe(Effect.andThen(Effect.logWarning(`Could not describe ${batch.length} row(s): ${error.message}`)), Effect.as(batch.map((request) => ({ id: request.id, note: null })))))), { concurrency: ATTRIBUTOR_CONCURRENCY });
+        const byId = new Map(answers.flat().map((answer) => [answer.id, answer.note]));
+        return requests.map((request) => byId.get(request.id) ?? null);
+    });
+    /** Both first reads and post-write refreshes subtract live totals through the same path. */
+    const refreshRecordedTime = Effect.fn("ReconcileService.refreshRecordedTime")(function* (period, previous, options) {
+        const { sides } = previous;
+        const stored = yield* sourceLedger.read.pipe(Effect.mapError((cause) => new ReconcileError({ message: cause.message, cause })));
+        const clockifySnapshot = sides.clockify ? yield* clockifyWriteSnapshot : null;
+        if (clockifySnapshot !== null) {
+            yield* sourceLedger.assertNoLegacyClockify(clockifySnapshot.legacyScope).pipe(Effect.mapError((cause) => new ReconcileError({ message: cause.message, cause })));
+        }
+        const clockifyScope = clockifySnapshot?.scope ?? null;
+        const jiraState = sides.jira ? yield* jiraWriteState : undefined;
+        const jiraSnapshot = jiraState?.snapshot ?? null;
+        // Compatibility reads may still render Jira totals, but only one verified snapshot may grant
+        // durable source authority. Independent Clockify work remains executable while Jira is held.
+        const jiraScope = jiraSnapshot?.ledgerScope ?? null;
+        const jiraHeldScope = jiraSnapshot?.heldScope ?? null;
+        const sourceScopes = { clockify: clockifyScope, jira: jiraHeldScope };
+        if (previous.sourceScopes !== undefined &&
+            ((sides.clockify && previous.sourceScopes.clockify !== null &&
+                clockifyScope !== null &&
+                previous.sourceScopes.clockify !== clockifyScope) ||
+                (sides.jira && previous.sourceScopes.jira !== null && jiraHeldScope !== null &&
+                    previous.sourceScopes.jira !== jiraHeldScope))) {
+            return yield* new ReconcileError({ message: "The provider account changed since this plan was read" });
+        }
+        const scoped = stored.bindings.filter((binding) => binding.provider === "clockify" ? binding.scope === clockifyScope : binding.scope === jiraScope);
+        if (previous.attributed.length > 0 &&
+            stored.pending.some((pending) => pending.provider === "clockify" ? pending.scope === clockifyScope : pending.scope === jiraScope)) {
+            return yield* new ReconcileError({ message: "An unresolved source write needs manual reconciliation" });
+        }
+        const jiraIssueKeys = [
+            ...new Set([
+                ...previous.attributed.map((row) => row.ticketKey),
+                ...scoped.filter((binding) => binding.provider === "jira").map((binding) => binding.ticketKey),
+                ...(options?.jiraIssueKeys ?? [])
+            ])
+        ];
+        const [{ recorded, unlinkedClockify }, excludedDays] = yield* Effect.all([
+            readRecorded(period, {
+                sides,
+                jiraIssueKeys,
+                clockifySnapshot: clockifySnapshot ?? undefined,
+                jiraSnapshot,
+                tolerateUnavailableJira: jiraState?.availability !== "verified"
+            }),
+            clockifySnapshot === null ? Effect.succeed([]) : runningTimerExclusions(period, clockifySnapshot)
+        ], { concurrency: 2 });
+        if (previous.attributed.length > 0 &&
+            recorded.some((row) => row.intervals.some((interval) => interval.source === "jira" && interval.entry === undefined))) {
+            return yield* new ReconcileError({
+                message: "Jira returned a worklog without an ID; session consumption needs manual review"
+            });
+        }
+        const entries = [
+            ...recorded.flatMap((row) => row.intervals.flatMap((interval) => interval.entry === undefined ? [] : [interval.entry])),
+            ...unlinkedClockify.flatMap((slice) => slice.entry === undefined ? [] : [slice.entry])
+        ];
+        const providerScopes = [
+            ["clockify", clockifyScope],
+            ["jira", jiraScope]
+        ];
+        for (const [provider, scope] of providerScopes) {
+            if (previous.attributed.length === 0)
+                break;
+            if (scope === null)
+                continue;
+            const known = stored.reviewedWindows.some((window) => window.provider === provider &&
+                window.scope === scope && window.fromMs <= period.from.getTime() && window.toMs >= period.to.getTime());
+            if (known)
+                continue;
+            const observed = [...new Map(entries.filter((entry) => entry.source === provider)
+                    .map((entry) => [entry.id, entry])).values()];
+            const markerBindings = observed.flatMap((entry) => {
+                const references = entry.description === null ? [] : SourceConsumption.sourceReferences(entry.description);
+                if (references.length !== 1 || entry.ticketKey === null)
+                    return [];
+                const reference = references[0];
+                if (reference === undefined)
+                    return [];
+                const sourceCredit = previous.attributed.find((credit) => `${credit.day}:${credit.ticketKey}` === reference.rowId);
+                if (sourceCredit === undefined ||
+                    !sourceCredit.blocks.some((block) => reference.sourceStartMs >= (block.sourceStartMs ?? block.startMs) &&
+                        reference.sourceStartMs < block.endMs))
+                    return [];
+                return [{
+                        provider,
+                        scope,
+                        entryId: entry.id,
+                        rowId: reference.rowId,
+                        sourceStartMs: reference.sourceStartMs,
+                        startMs: entry.startMs,
+                        endMs: entry.endMs,
+                        seconds: (entry.endMs - entry.startMs) / 1000,
+                        ticketKey: entry.ticketKey
+                    }];
+            });
+            const verified = [
+                ...stored.bindings.filter((binding) => binding.provider === provider && binding.scope === scope &&
+                    observed.some((entry) => entry.id === binding.entryId)),
+                ...markerBindings.filter((binding) => !stored.bindings.some((knownBinding) => knownBinding.provider === provider && knownBinding.scope === scope &&
+                    knownBinding.entryId === binding.entryId))
+            ];
+            yield* sourceLedger.ensureWindow({
+                provider,
+                scope,
+                fromMs: period.from.getTime(),
+                toMs: period.to.getTime()
+            }, observed.map((entry) => ({ entryId: entry.id, startMs: entry.startMs })), verified, provider === "clockify" ? clockifySnapshot?.legacyScope : undefined).pipe(Effect.mapError((cause) => new ReconcileError({ message: cause.message, cause })));
+        }
+        const verifiedLedger = yield* sourceLedger.read.pipe(Effect.mapError((cause) => new ReconcileError({ message: cause.message, cause })));
+        if (previous.attributed.length > 0 &&
+            entries.some((entry) => {
+                const scope = entry.source === "clockify" ? clockifyScope : jiraScope;
+                return scope !== null && entry.description !== null &&
+                    SourceConsumption.markers(entry.description).length > 0 &&
+                    !verifiedLedger.bindings.some((binding) => binding.provider === entry.source && binding.entryId === entry.id && binding.scope === scope);
+            })) {
+            return yield* new ReconcileError({
+                message: "An unlinked source marker needs private manual review before session writes"
+            });
+        }
+        const sourceEntries = verifiedLedger.bindings.filter((binding) => binding.provider === "clockify" ? binding.scope === clockifyScope : binding.scope === jiraScope).flatMap((binding) => {
+            const entry = entries.find((candidate) => candidate.source === binding.provider && candidate.id === binding.entryId);
+            return entry === undefined ? [] : [{
+                    source: binding.provider,
+                    id: binding.entryId,
+                    rowId: binding.rowId,
+                    sourceStartMs: binding.sourceStartMs,
+                    startMs: entry.startMs,
+                    endMs: entry.endMs
+                }];
+        });
+        const executableRecorded = recordedForExecution(recorded, jiraState?.availability);
+        return {
+            ...previous,
+            proposals: buildSessionProposals(previous.attributed, executableRecorded, {
+                minimumSeconds: MINIMUM_PROPOSAL_SECONDS,
+                excludedDays: excludedDays.map((excluded) => excluded.day),
+                sides,
+                sourceEntries,
+                consumptionRows: unlinkedClockify.map((slice) => ({
+                    day: slice.day,
+                    intervals: slice.entry === undefined ? [] : [{ entry: slice.entry }]
+                }))
+            }),
+            recorded,
+            unlinkedClockify,
+            sourceEntries,
+            sourceScopes,
+            jiraAvailability: jiraState?.availability,
+            excludedDays
+        };
+    });
+    const proposeFromSessions = (period, options) => Effect.gen(function* () {
+        const onProgress = options?.onProgress ?? (() => Effect.void);
+        const cfg = yield* config.get;
+        const sessions = yield* sessionReader.read(period).pipe(Effect.mapError((error) => new ReconcileError({ message: error.message, cause: error })));
+        yield* onProgress({ _tag: "SessionsRead", count: sessions.length });
+        const { attributions, attributorAvailable, attributorCalls } = yield* attributeSessions(sessions, {
+            standingMap: expandedStandingMap(cfg.sessionTicketMap, home),
+            confidenceFloor: cfg.sessionConfidenceFloor,
+            mode: options?.attribution ?? "full",
+            onProgress
+        });
+        // Windows first, then attribution, then sharing — in that order, because time is divided
+        // between distinct Issue Keys, not between sessions. Two sessions on one ticket must union
+        // their windows rather than halve each other.
+        const nowMs = yield* Clock.currentTimeMillis;
+        const windows = activeWindows(sessions.flatMap((session) => session.activity), {
+            idleCapSeconds: cfg.sessionIdleCapSeconds,
+            // The end of the window being reconciled — which for a watch is now. Presence is never
+            // credited past what this run can see.
+            observedAtMs: Math.min(period.to.getTime(), nowMs),
+            boundsBySession: new Map(sessions.flatMap((session) => session.boundedAtMs === null ? [] : [[session.sessionId, session.boundedAtMs]]))
+        });
+        const split = splitCredits(windows, attributions, {
+            cwdBySession: new Map(sessions.map((session) => [session.sessionId, session.cwd])),
+            dwellSeconds: cfg.sessionDwellSeconds
+        });
+        const sides = options?.sides ?? bothSides;
+        yield* onProgress({ _tag: "ReadingRecordedTime", sides });
+        return yield* refreshRecordedTime(period, {
+            attributed: split.attributed,
+            sessionEvidence: windows.map((window) => ({
+                ...window,
+                ticketKey: attributions.find((attribution) => attribution.sessionId === window.sessionId)?.ticketKey ?? null
+            })),
+            sides,
+            withheld: split.withheld,
+            unattributed: split.unattributed,
+            attributorAvailable,
+            sessionCount: sessions.length,
+            sessionRootCount: cfg.sessionRoots.length,
+            attributorCalls,
+            digests: new Map(sessions.map((session) => [session.sessionId, session.digest]))
+        });
+    });
+    return {
+        compare,
+        compareDirection,
+        applyToJira,
+        applyToClockify,
+        describeProposals,
+        proposeFromSessions,
+        refreshRecordedTime
+    };
 }));
 //# sourceMappingURL=ReconcileService.js.map