perttool 0.3.0 → 0.5.0

package/dist/history/project-history.js

@@ -0,0 +1,786 @@
+import { createHash } from "node:crypto";
+import { reduceTaskLifecycle, } from "../actuals/lifecycle.js";
+import { projectActualsSourceModel, } from "../actuals/source.js";
+import { instantKey } from "../model/calendar-arithmetic.js";
+import { compareStableStrings, sortDiagnostics, } from "../model/diagnostics.js";
+import { add, divide, formatDecimal, multiply, rational, rationalFromDuration, subtract, } from "../model/rational.js";
+import { fieldNamed } from "../model/syntax.js";
+import { projectDeclaredCalendarValue, } from "../model/target-calendar.js";
+import { validateTargetGrammar5Document, } from "../semantic/target-validator.js";
+export const PROJECT_HISTORY_MODEL_VERSION = 1;
+const historyCauseOrder = [
+    "no_repository",
+    "no_head",
+    "unknown_revision",
+    "untracked_target",
+    "ambiguous_path",
+    "shallow_boundary",
+    "unsupported_rename",
+    "unsupported_source_version",
+    "task_identity_replaced",
+    "event_payload_changed",
+    "duplicate_event_identity",
+    "head_changed",
+    "target_changed",
+];
+const actualsCauseOrder = [
+    "missing_start",
+    "missing_finish",
+    "open_suspension",
+    "missing_baseline",
+    "active_time_absent",
+    "effort_absent",
+    "history_incomplete",
+    "history_unavailable",
+];
+const eventKindOrder = Object.freeze({
+    start: 0,
+    suspend: 1,
+    resume: 2,
+    finish: 3,
+});
+const identifierPattern = /^[A-Za-z][A-Za-z0-9_-]*$/;
+function quantity(value, unit) {
+    return Object.freeze({
+        numerator: value.numerator.toString(),
+        denominator: value.denominator.toString(),
+        unit,
+        display: formatDecimal(value, 6),
+    });
+}
+function durationUnit(suffix) {
+    return suffix === "d" ? "day" : suffix === "h" ? "hour" : "point";
+}
+function exactDuration(declaration, name) {
+    const field = fieldNamed(declaration, name);
+    if (field === undefined ||
+        field.value === null ||
+        typeof field.value !== "object" ||
+        !("suffix" in field.value)) {
+        throw new Error(`validated task ${declaration.id} is missing ${name}`);
+    }
+    return field.value;
+}
+function exactEstimate(declaration, name) {
+    const estimate = fieldNamed(declaration, "estimate");
+    const child = estimate?.children?.find(({ name: childName }) => childName === name);
+    if (child === undefined ||
+        child.value === null ||
+        typeof child.value !== "object" ||
+        !("suffix" in child.value)) {
+        throw new Error(`validated task ${declaration.id} estimate is missing ${name}`);
+    }
+    return child.value;
+}
+function taskPlannedValue(declaration) {
+    const estimate = fieldNamed(declaration, "estimate");
+    if (estimate === undefined) {
+        const duration = exactDuration(declaration, "duration");
+        return quantity(rationalFromDuration(duration), durationUnit(duration.suffix));
+    }
+    const optimistic = exactEstimate(declaration, "optimistic");
+    const mostLikely = exactEstimate(declaration, "most_likely");
+    const pessimistic = exactEstimate(declaration, "pessimistic");
+    const expected = divide(add(add(rationalFromDuration(optimistic), multiply(rational(4n), rationalFromDuration(mostLikely))), rationalFromDuration(pessimistic)), rational(6n));
+    return quantity(expected, durationUnit(optimistic.suffix));
+}
+function taskState(declaration) {
+    return (fieldNamed(declaration, "status")?.value ?? "planned");
+}
+function taskIdentity(declaration) {
+    return `${declaration.from ?? ""}\u0000${declaration.to ?? ""}`;
+}
+function eventQuantity(value, unit) {
+    return value === null ? null : quantity(value.value, unit);
+}
+function eventProjection(event) {
+    const occurredAt = projectDeclaredCalendarValue(event.occurredAt);
+    if (occurredAt === null) {
+        throw new Error("validated work event lost its calendar projection");
+    }
+    return Object.freeze({
+        modelVersion: 1,
+        id: event.id,
+        taskId: event.taskId,
+        kind: event.kind,
+        occurredAt,
+        plannedValue: event.plannedValue === null
+            ? null
+            : quantity(event.plannedValue.value, event.plannedValue.unit),
+        activeTime: eventQuantity(event.activeTime, "hour"),
+        effort: eventQuantity(event.effort, "person_hour"),
+        reason: event.reason,
+    });
+}
+function payloadDigest(projection) {
+    const payload = JSON.stringify({
+        model_version: projection.modelVersion,
+        id: projection.id,
+        task_id: projection.taskId,
+        kind: projection.kind,
+        occurred_at: projection.occurredAt,
+        planned_value: projection.plannedValue,
+        active_time: projection.activeTime,
+        effort: projection.effort,
+        reason: projection.reason,
+    });
+    return `sha256:${createHash("sha256").update(payload, "utf8").digest("hex")}`;
+}
+function historyCause(cause, fields = {}) {
+    return Object.freeze({
+        cause,
+        commitId: fields.commitId ?? null,
+        taskId: fields.taskId ?? null,
+        eventId: fields.eventId ?? null,
+    });
+}
+function actualsCause(cause, taskId, fields = {}) {
+    return Object.freeze({
+        cause,
+        commitId: fields.commitId ?? null,
+        taskId,
+        eventId: fields.eventId ?? null,
+    });
+}
+function diagnostic(cause) {
+    const unavailable = new Set([
+        "no_repository",
+        "no_head",
+        "unknown_revision",
+        "untracked_target",
+        "ambiguous_path",
+    ]);
+    const race = cause.cause === "head_changed" ||
+        cause.cause === "target_changed";
+    const conflict = cause.cause === "event_payload_changed" ||
+        cause.cause === "duplicate_event_identity";
+    const code = race
+        ? "PTHIS-104"
+        : conflict
+            ? "PTHIS-103"
+            : unavailable.has(cause.cause)
+                ? "PTHIS-101"
+                : "PTHIS-102";
+    const severity = code === "PTHIS-102" ? "warning" : "error";
+    const message = code === "PTHIS-104"
+        ? "repository snapshot changed during history inspection"
+        : code === "PTHIS-103"
+            ? "conflicting work-event history"
+            : code === "PTHIS-101"
+                ? "project history is unavailable"
+                : "project history is incomplete";
+    return Object.freeze({
+        code,
+        severity,
+        message,
+        ...(cause.eventId === null && cause.taskId === null
+            ? {}
+            : { entityId: cause.eventId ?? cause.taskId }),
+        helpTopic: "project.history",
+        data: Object.freeze({
+            cause: cause.cause,
+            commit_id: cause.commitId,
+            task_id: cause.taskId,
+            event_id: cause.eventId,
+        }),
+    });
+}
+function compareNullable(left, right) {
+    return compareStableStrings(left ?? "", right ?? "");
+}
+function sortedHistoryCauses(causes) {
+    const order = new Map(historyCauseOrder.map((cause, index) => [cause, index]));
+    const seen = new Set();
+    return Object.freeze([...causes]
+        .sort((left, right) => order.get(left.cause) - order.get(right.cause) ||
+        compareNullable(left.commitId, right.commitId) ||
+        compareNullable(left.taskId, right.taskId) ||
+        compareNullable(left.eventId, right.eventId))
+        .filter((cause) => {
+        const key = JSON.stringify(cause);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    }));
+}
+function sortedActualsCauses(causes) {
+    const order = new Map(actualsCauseOrder.map((cause, index) => [cause, index]));
+    const seen = new Set();
+    return Object.freeze([...causes]
+        .sort((left, right) => order.get(left.cause) - order.get(right.cause) ||
+        compareNullable(left.commitId, right.commitId) ||
+        compareNullable(left.taskId, right.taskId) ||
+        compareNullable(left.eventId, right.eventId))
+        .filter((cause) => {
+        const key = JSON.stringify(cause);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    }));
+}
+function fromProbeAvailability(value) {
+    return historyCause(value.cause, { commitId: value.commitId });
+}
+function unsupportedSnapshot(snapshot) {
+    return historyCause("unsupported_source_version", {
+        commitId: snapshot.commitId,
+    });
+}
+function decodeSnapshot(snapshot) {
+    if (snapshot.source === null)
+        return null;
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(snapshot.source);
+    }
+    catch {
+        return null;
+    }
+}
+function parseSnapshot(snapshot, capability) {
+    if (snapshot.source === null) {
+        return {
+            parsed: {
+                snapshot,
+                documentId: null,
+                grammarVersion: null,
+                tasks: new Map(),
+                events: Object.freeze([]),
+            },
+            causes: Object.freeze([]),
+        };
+    }
+    const text = decodeSnapshot(snapshot);
+    if (text === null) {
+        return {
+            parsed: null,
+            causes: Object.freeze([unsupportedSnapshot(snapshot)]),
+        };
+    }
+    const checked = validateTargetGrammar5Document(text, capability);
+    const project = checked.document.declarations.find(({ kind }) => kind === "project");
+    const declaredVersion = project === undefined
+        ? null
+        : fieldNamed(project, "version")?.value ?? 1;
+    const duplicateIds = checked.document.declarations
+        .filter(({ kind }) => kind === "work_event")
+        .map(({ id }) => id)
+        .filter((id, index, ids) => ids.indexOf(id) !== index);
+    if (duplicateIds.length > 0) {
+        return {
+            parsed: null,
+            causes: Object.freeze([...new Set(duplicateIds)]
+                .sort(compareStableStrings)
+                .map((eventId) => historyCause("duplicate_event_identity", {
+                commitId: snapshot.commitId,
+                eventId,
+            }))),
+        };
+    }
+    if (!checked.ok ||
+        checked.validatedDocument === null ||
+        (declaredVersion !== 1 &&
+            declaredVersion !== 2 &&
+            declaredVersion !== 3 &&
+            declaredVersion !== 4 &&
+            declaredVersion !== 5)) {
+        return {
+            parsed: null,
+            causes: Object.freeze([unsupportedSnapshot(snapshot)]),
+        };
+    }
+    const tasks = new Map();
+    for (const declaration of checked.validatedDocument.document.declarations) {
+        if (declaration.kind !== "task")
+            continue;
+        tasks.set(declaration.id, {
+            state: taskState(declaration),
+            identity: taskIdentity(declaration),
+            plannedValue: taskPlannedValue(declaration),
+        });
+    }
+    return {
+        parsed: {
+            snapshot,
+            documentId: checked.documentId,
+            grammarVersion: checked.validatedDocument.grammarVersion,
+            tasks,
+            events: projectActualsSourceModel(checked.validatedDocument).events,
+        },
+        causes: Object.freeze([]),
+    };
+}
+function compareEvents(left, right) {
+    const instantOrder = (instantKey(left.occurredAt).numerator *
+        instantKey(right.occurredAt).denominator -
+        instantKey(right.occurredAt).numerator *
+            instantKey(left.occurredAt).denominator);
+    if (instantOrder !== 0n)
+        return instantOrder < 0n ? -1 : 1;
+    return eventKindOrder[left.kind] - eventKindOrder[right.kind] ||
+        compareStableStrings(left.id, right.id);
+}
+function hoursBetween(start, finish) {
+    return quantity(divide(subtract(instantKey(finish.occurredAt), instantKey(start.occurredAt)), rational(3600n)), "hour");
+}
+function suspensionIntervals(events) {
+    const ordered = [...events].sort(compareEvents);
+    const result = [];
+    let suspended = null;
+    for (const event of ordered) {
+        if (event.kind === "suspend") {
+            suspended = event;
+            continue;
+        }
+        if (suspended !== null &&
+            (event.kind === "resume" || event.kind === "finish")) {
+            const start = projectDeclaredCalendarValue(suspended.occurredAt);
+            const finish = projectDeclaredCalendarValue(event.occurredAt);
+            if (start === null || finish === null) {
+                throw new Error("validated suspension interval lost calendar values");
+            }
+            result.push(Object.freeze({
+                suspendEventId: suspended.id,
+                resumeEventId: event.kind === "resume" ? event.id : null,
+                start,
+                finish,
+                duration: hoursBetween(suspended, event),
+            }));
+            suspended = null;
+        }
+    }
+    if (suspended !== null) {
+        const start = projectDeclaredCalendarValue(suspended.occurredAt);
+        if (start === null) {
+            throw new Error("validated open suspension lost its calendar value");
+        }
+        result.push(Object.freeze({
+            suspendEventId: suspended.id,
+            resumeEventId: null,
+            start,
+            finish: null,
+            duration: null,
+        }));
+    }
+    return Object.freeze(result);
+}
+function summaryForTask(taskId, eventEntries, transitions, plannedByCommit, historyStatus, identityReplaced) {
+    if (identityReplaced) {
+        return Object.freeze({
+            taskId,
+            coverage: "unavailable",
+            eventIds: Object.freeze([]),
+            firstStart: null,
+            lastFinish: null,
+            suspensionIntervals: Object.freeze([]),
+            cycleTime: null,
+            derivedActiveTime: null,
+            explicitActiveTime: null,
+            effort: null,
+            plannedValue: null,
+            baselineSource: null,
+            baselineEventId: null,
+            baselineCommitId: null,
+            qualifiers: Object.freeze(["history_incomplete"]),
+            unavailableCauses: Object.freeze([
+                actualsCause("history_incomplete", taskId),
+            ]),
+        });
+    }
+    const entries = eventEntries
+        .filter(({ event }) => event.taskId === taskId)
+        .sort((left, right) => compareEvents(left.event, right.event));
+    const events = entries.map(({ event }) => event);
+    const reduction = reduceTaskLifecycle(events);
+    const firstStartEntry = entries.find(({ event }) => event.kind === "start") ??
+        null;
+    const finishEntries = entries.filter(({ event }) => event.kind === "finish");
+    const lastFinishEntry = finishEntries.at(-1) ?? null;
+    const firstStart = firstStartEntry === null
+        ? null
+        : projectDeclaredCalendarValue(firstStartEntry.event.occurredAt);
+    const lastFinish = lastFinishEntry === null
+        ? null
+        : projectDeclaredCalendarValue(lastFinishEntry.event.occurredAt);
+    const complete = reduction.ok && reduction.coverage === "complete";
+    const cycleTime = complete && firstStartEntry !== null && lastFinishEntry !== null
+        ? hoursBetween(firstStartEntry.event, lastFinishEntry.event)
+        : null;
+    const finishEvent = lastFinishEntry?.event ?? null;
+    const explicitActiveTime = finishEvent === null
+        ? null
+        : eventQuantity(finishEvent.activeTime, "hour");
+    const effort = finishEvent === null
+        ? null
+        : eventQuantity(finishEvent.effort, "person_hour");
+    let plannedValue = null;
+    let baselineSource = null;
+    let baselineEventId = null;
+    let baselineCommitId = null;
+    if (firstStartEntry !== null &&
+        firstStartEntry.event.plannedValue !== null) {
+        plannedValue = quantity(firstStartEntry.event.plannedValue.value, firstStartEntry.event.plannedValue.unit);
+        baselineSource = "start_baseline";
+        baselineEventId = firstStartEntry.event.id;
+        baselineCommitId = firstStartEntry.firstSeenCommitId;
+    }
+    else if (reduction.ok &&
+        reduction.coverage === "finish_only" &&
+        lastFinishEntry !== null) {
+        plannedValue =
+            plannedByCommit.get(lastFinishEntry.lastSeenCommitId)?.get(taskId) ??
+                null;
+        baselineSource = plannedValue === null ? null : "finish_snapshot";
+        baselineEventId = plannedValue === null ? null : lastFinishEntry.event.id;
+        baselineCommitId =
+            plannedValue === null ? null : lastFinishEntry.lastSeenCommitId;
+    }
+    else if (reduction.ok &&
+        reduction.coverage === "unrecorded") {
+        const recordedFinish = transitions
+            .filter((transition) => transition.taskId === taskId &&
+            transition.toState === "done")
+            .at(-1);
+        if (recordedFinish !== undefined) {
+            plannedValue =
+                plannedByCommit.get(recordedFinish.commitId)?.get(taskId) ?? null;
+            baselineSource = plannedValue === null ? null : "finish_snapshot";
+            baselineCommitId =
+                plannedValue === null ? null : recordedFinish.commitId;
+        }
+    }
+    const causes = [];
+    const coverage = reduction.ok ? reduction.coverage : "unavailable";
+    if (firstStartEntry === null) {
+        causes.push(actualsCause("missing_start", taskId));
+    }
+    if (lastFinishEntry === null) {
+        causes.push(actualsCause("missing_finish", taskId));
+    }
+    if (reduction.ok &&
+        reduction.coverage === "open" &&
+        reduction.state === "suspended") {
+        causes.push(actualsCause("open_suspension", taskId));
+    }
+    if (plannedValue === null) {
+        causes.push(actualsCause("missing_baseline", taskId));
+    }
+    if (explicitActiveTime === null) {
+        causes.push(actualsCause("active_time_absent", taskId));
+    }
+    if (effort === null) {
+        causes.push(actualsCause("effort_absent", taskId));
+    }
+    if (historyStatus === "incomplete") {
+        causes.push(actualsCause("history_incomplete", taskId));
+    }
+    else if (historyStatus === "unavailable" || !reduction.ok) {
+        causes.push(actualsCause("history_unavailable", taskId));
+    }
+    const qualifiers = [
+        ...(baselineSource === "finish_snapshot" ? ["finish_snapshot"] : []),
+        ...(historyStatus === "incomplete" ? ["history_incomplete"] : []),
+        ...(historyStatus === "unavailable" ? ["history_unavailable"] : []),
+    ];
+    return Object.freeze({
+        taskId,
+        coverage,
+        eventIds: Object.freeze(entries.map(({ event }) => event.id)),
+        firstStart,
+        lastFinish,
+        suspensionIntervals: suspensionIntervals(events),
+        cycleTime,
+        derivedActiveTime: reduction.ok && reduction.derivedActiveTime !== null
+            ? quantity(reduction.derivedActiveTime, "hour")
+            : null,
+        explicitActiveTime,
+        effort,
+        plannedValue,
+        baselineSource,
+        baselineEventId,
+        baselineCommitId,
+        qualifiers: Object.freeze(qualifiers),
+        unavailableCauses: sortedActualsCauses(causes),
+    });
+}
+function statusForCauses(probeStatus, causes) {
+    if (probeStatus === "unavailable" ||
+        causes.some(({ cause }) => cause === "no_repository" ||
+            cause === "no_head" ||
+            cause === "unknown_revision" ||
+            cause === "untracked_target" ||
+            cause === "ambiguous_path" ||
+            cause === "event_payload_changed" ||
+            cause === "duplicate_event_identity" ||
+            cause === "head_changed" ||
+            cause === "target_changed")) {
+        return "unavailable";
+    }
+    return probeStatus === "incomplete" || causes.length > 0
+        ? "incomplete"
+        : "complete";
+}
+function emptyResult(probe, causes) {
+    const sortedCauses = sortedHistoryCauses(causes);
+    return Object.freeze({
+        ok: false,
+        modelVersion: PROJECT_HISTORY_MODEL_VERSION,
+        documentId: null,
+        grammarVersion: null,
+        history: Object.freeze({
+            id: "perttool.project-history",
+            version: 1,
+            status: "unavailable",
+            traversal: "first_parent",
+            repositorySnapshotId: probe.repositorySnapshotId,
+            repositoryRelativePath: probe.repositoryRelativePath,
+            requestedRevision: probe.requestedRevision,
+            resolvedRevision: probe.resolvedRevision,
+            sourceDigest: probe.selectedSourceDigest,
+            inspectedCommitIds: Object.freeze([...probe.inspectedCommitIds]),
+            unavailableCauses: sortedCauses,
+        }),
+        events: Object.freeze([]),
+        gitRecordedTransitions: Object.freeze([]),
+        tasks: Object.freeze([]),
+        diagnostics: Object.freeze(sortDiagnostics(sortedCauses.map(diagnostic))),
+    });
+}
+function invalidRequestResult(probe, cause, taskId) {
+    return Object.freeze({
+        ok: false,
+        modelVersion: PROJECT_HISTORY_MODEL_VERSION,
+        documentId: null,
+        grammarVersion: null,
+        history: Object.freeze({
+            id: "perttool.project-history",
+            version: 1,
+            status: "unavailable",
+            traversal: "first_parent",
+            repositorySnapshotId: probe.repositorySnapshotId,
+            repositoryRelativePath: probe.repositoryRelativePath,
+            requestedRevision: probe.requestedRevision,
+            resolvedRevision: probe.resolvedRevision,
+            sourceDigest: probe.selectedSourceDigest,
+            inspectedCommitIds: Object.freeze([...probe.inspectedCommitIds]),
+            unavailableCauses: Object.freeze([]),
+        }),
+        events: Object.freeze([]),
+        gitRecordedTransitions: Object.freeze([]),
+        tasks: Object.freeze([]),
+        diagnostics: Object.freeze([
+            Object.freeze({
+                code: "PTCLI-001",
+                severity: "error",
+                message: "invalid project history task selection",
+                ...(taskId === null ? {} : { entityId: taskId }),
+                helpTopic: "project.history",
+                data: Object.freeze({
+                    usage_kind: "invalid_option_value",
+                    cause,
+                    task_id: taskId,
+                }),
+            }),
+        ]),
+    });
+}
+export function inspectProjectHistory(probe, request, capability) {
+    const adapterCauses = probe.availability.map(fromProbeAvailability);
+    if (probe.status === "unavailable") {
+        return emptyResult(probe, adapterCauses);
+    }
+    const selectedTaskIds = request.taskIds === undefined
+        ? null
+        : [...request.taskIds].sort(compareStableStrings);
+    if (selectedTaskIds !== null) {
+        const invalidTaskId = selectedTaskIds.find((taskId) => !identifierPattern.test(taskId));
+        if (invalidTaskId !== undefined) {
+            return invalidRequestResult(probe, "invalid_task_id", invalidTaskId);
+        }
+        const duplicateTaskId = selectedTaskIds.find((taskId, index) => selectedTaskIds.indexOf(taskId) !== index);
+        if (duplicateTaskId !== undefined) {
+            return invalidRequestResult(probe, "duplicate_task", duplicateTaskId);
+        }
+    }
+    const causes = [...adapterCauses];
+    const transitions = [];
+    const eventMap = new Map();
+    const conflictedEventIds = new Set();
+    const eventfulTaskIds = new Set();
+    const taskIdentities = new Map();
+    const replacedTaskIds = new Set();
+    const allTaskIds = new Set();
+    const plannedByCommit = new Map();
+    let previousTasks = new Map();
+    let previousEventIds = new Set();
+    let previousSourceDigest = null;
+    let transitionContinuityKnown = !adapterCauses.some(({ cause }) => cause === "shallow_boundary" || cause === "unsupported_rename");
+    let documentId = null;
+    let grammarVersion = null;
+    for (const snapshot of probe.snapshots) {
+        const parsedSnapshot = parseSnapshot(snapshot, capability);
+        causes.push(...parsedSnapshot.causes);
+        if (parsedSnapshot.parsed === null) {
+            transitionContinuityKnown = false;
+            previousEventIds = new Set();
+            continue;
+        }
+        const parsed = parsedSnapshot.parsed;
+        if (parsed.documentId !== null)
+            documentId = parsed.documentId;
+        if (parsed.grammarVersion !== null) {
+            grammarVersion = parsed.grammarVersion;
+        }
+        plannedByCommit.set(snapshot.commitId, new Map([...parsed.tasks].map(([taskId, task]) => [
+            taskId,
+            task.plannedValue,
+        ])));
+        const replacedInSnapshot = new Set();
+        for (const [taskId, task] of parsed.tasks) {
+            allTaskIds.add(taskId);
+            const priorIdentity = taskIdentities.get(taskId);
+            if (priorIdentity !== undefined && priorIdentity !== task.identity) {
+                causes.push(historyCause("task_identity_replaced", {
+                    commitId: snapshot.commitId,
+                    taskId,
+                }));
+                replacedTaskIds.add(taskId);
+                replacedInSnapshot.add(taskId);
+                taskIdentities.set(taskId, task.identity);
+            }
+            else if (priorIdentity === undefined) {
+                taskIdentities.set(taskId, task.identity);
+            }
+        }
+        const currentEventsById = new Map(parsed.events.map((event) => [event.id, event]));
+        for (const eventId of previousEventIds) {
+            if (currentEventsById.has(eventId))
+                continue;
+            const accumulator = eventMap.get(eventId);
+            if (accumulator !== undefined &&
+                accumulator.removalCommitId === null) {
+                accumulator.removalCommitId = snapshot.commitId;
+            }
+        }
+        for (const event of parsed.events) {
+            allTaskIds.add(event.taskId);
+            eventfulTaskIds.add(event.taskId);
+            const projection = eventProjection(event);
+            const digest = payloadDigest(projection);
+            const existing = eventMap.get(event.id);
+            if (existing === undefined) {
+                eventMap.set(event.id, {
+                    event,
+                    projection,
+                    payloadDigest: digest,
+                    firstSeenCommitId: snapshot.commitId,
+                    lastSeenCommitId: snapshot.commitId,
+                    removalCommitId: null,
+                });
+            }
+            else if (existing.payloadDigest !== digest ||
+                existing.removalCommitId !== null) {
+                conflictedEventIds.add(event.id);
+                const cause = existing.removalCommitId === null
+                    ? "event_payload_changed"
+                    : "duplicate_event_identity";
+                causes.push(historyCause(cause, {
+                    commitId: existing.firstSeenCommitId,
+                    taskId: existing.event.taskId,
+                    eventId: event.id,
+                }), historyCause(cause, {
+                    commitId: snapshot.commitId,
+                    taskId: event.taskId,
+                    eventId: event.id,
+                }));
+            }
+            else {
+                existing.lastSeenCommitId = snapshot.commitId;
+            }
+        }
+        const transitionTaskIds = new Set([
+            ...previousTasks.keys(),
+            ...parsed.tasks.keys(),
+        ]);
+        for (const taskId of [...transitionTaskIds].sort(compareStableStrings)) {
+            const fromState = previousTasks.get(taskId)?.state ?? "absent";
+            const toState = parsed.tasks.get(taskId)?.state ?? "absent";
+            if (!transitionContinuityKnown ||
+                fromState === toState ||
+                replacedInSnapshot.has(taskId) ||
+                eventfulTaskIds.has(taskId)) {
+                continue;
+            }
+            const recordedAt = snapshot.recordedAt === null
+                ? null
+                : projectDeclaredCalendarValue(snapshot.recordedAt);
+            transitions.push(Object.freeze({
+                taskId,
+                fromState,
+                toState,
+                commitId: snapshot.commitId,
+                recordedAt,
+                sourceDigest: snapshot.sourceDigest ?? previousSourceDigest ?? "",
+                evidenceClass: "git_recorded_transition",
+            }));
+        }
+        previousTasks = new Map(parsed.tasks);
+        previousEventIds = new Set(currentEventsById.keys());
+        previousSourceDigest = snapshot.sourceDigest;
+        transitionContinuityKnown = true;
+    }
+    const sortedCauses = sortedHistoryCauses(causes);
+    const status = statusForCauses(probe.status, sortedCauses);
+    if (status === "unavailable") {
+        return emptyResult(probe, sortedCauses);
+    }
+    const eventEntries = [...eventMap]
+        .filter(([eventId]) => !conflictedEventIds.has(eventId))
+        .map(([, value]) => value)
+        .sort((left, right) => compareStableStrings(left.event.id, right.event.id));
+    const historyEvents = Object.freeze(eventEntries.map((entry) => Object.freeze({
+        event: entry.projection,
+        evidenceClass: "declared_actual",
+        firstSeenCommitId: entry.firstSeenCommitId,
+        lastSeenCommitId: entry.lastSeenCommitId,
+        removalCommitId: entry.removalCommitId,
+        payloadDigest: entry.payloadDigest,
+    })));
+    const summaryTaskIds = selectedTaskIds ??
+        [...allTaskIds].sort(compareStableStrings);
+    const tasks = Object.freeze(summaryTaskIds.map((taskId) => summaryForTask(taskId, eventEntries, transitions, plannedByCommit, status, replacedTaskIds.has(taskId))));
+    const selected = selectedTaskIds === null
+        ? () => true
+        : (taskId) => selectedTaskIds.includes(taskId);
+    const filteredEvents = Object.freeze(historyEvents.filter(({ event }) => selected(event.taskId)));
+    const filteredTransitions = Object.freeze(transitions
+        .filter(({ taskId }) => selected(taskId))
+        .sort((left, right) => probe.inspectedCommitIds.indexOf(left.commitId) -
+        probe.inspectedCommitIds.indexOf(right.commitId) ||
+        compareStableStrings(left.taskId, right.taskId)));
+    return Object.freeze({
+        ok: true,
+        modelVersion: PROJECT_HISTORY_MODEL_VERSION,
+        documentId,
+        grammarVersion,
+        history: Object.freeze({
+            id: "perttool.project-history",
+            version: 1,
+            status,
+            traversal: "first_parent",
+            repositorySnapshotId: probe.repositorySnapshotId,
+            repositoryRelativePath: probe.repositoryRelativePath,
+            requestedRevision: probe.requestedRevision,
+            resolvedRevision: probe.resolvedRevision,
+            sourceDigest: probe.selectedSourceDigest,
+            inspectedCommitIds: Object.freeze([...probe.inspectedCommitIds]),
+            unavailableCauses: sortedCauses,
+        }),
+        events: filteredEvents,
+        gitRecordedTransitions: filteredTransitions,
+        tasks,
+        diagnostics: Object.freeze(sortDiagnostics(sortedCauses.map(diagnostic))),
+    });
+}
+//# sourceMappingURL=project-history.js.map