agent-dealer 1.1.4 → 1.1.5

package/bundle/server/dist/coordinator/attempt-waste.js

@@ -0,0 +1,330 @@
+import { CheckpointObservedPayload, RetryReusedPayload } from "@agent-dealer/shared";
+import { getDb } from "../db/index.js";
+function msOf(ts) {
+    if (!ts)
+        return null;
+    const ms = Date.parse(ts);
+    return Number.isFinite(ms) ? ms : null;
+}
+function withPartialSample(base) {
+    const reasons = [...(base.reasons ?? [])];
+    if (base.known < base.total && !reasons.includes("partial_sample"))
+        reasons.push("partial_sample");
+    return { ...base, reasons };
+}
+function orderCheckpoints(checkpoints) {
+    return [...checkpoints].sort((a, b) => {
+        const ta = msOf(a.observedAt ?? a.ts) ?? 0;
+        const tb = msOf(b.observedAt ?? b.ts) ?? 0;
+        return ta - tb || a.cursor - b.cursor;
+    });
+}
+export function deriveFirstCheckpoint(input) {
+    const ordered = orderCheckpoints(input.checkpoints);
+    const startMs = msOf(input.workflowStartedAt);
+    const first = ordered[0] ?? null;
+    if (first) {
+        const atMs = msOf(first.observedAt ?? first.ts);
+        if (startMs === null || atMs === null) {
+            return { kind: first.kind, observedSha: first.observedSha, msSinceWorkflowStart: null, quality: "unavailable", reasons: ["no_defensible_boundary"] };
+        }
+        if (atMs < startMs) {
+            return { kind: first.kind, observedSha: first.observedSha, msSinceWorkflowStart: null, quality: "unavailable", reasons: ["negative_duration"] };
+        }
+        return { kind: first.kind, observedSha: first.observedSha, msSinceWorkflowStart: atMs - startMs, quality: "exact", reasons: [] };
+    }
+    const legacyMs = msOf(input.legacyFirstEvidenceAt);
+    if (startMs !== null && legacyMs !== null) {
+        if (legacyMs < startMs) {
+            return { kind: null, observedSha: null, msSinceWorkflowStart: null, quality: "unavailable", reasons: ["negative_duration"] };
+        }
+        return { kind: null, observedSha: null, msSinceWorkflowStart: legacyMs - startMs, quality: "inferred", reasons: ["backfill"] };
+    }
+    return { kind: null, observedSha: null, msSinceWorkflowStart: null, quality: "unavailable", reasons: ["missing_checkpoint"] };
+}
+/**
+ * Waste includes agent-process/usage from attempts whose primary result is
+ * failed/timed_out/cancelled for a failure. A later successful retry never
+ * erases prior waste. `cancelled` counts only with failure evidence
+ * (errorJson) — a clean operator cancel discarded nothing.
+ */
+export function isWastedSession(session) {
+    if (session.status === "failed" || session.status === "timed_out")
+        return true;
+    if (session.status === "cancelled")
+        return session.errorJson != null;
+    return false;
+}
+function unavailableAggregate(total, reason) {
+    return { value: null, quality: "unavailable", reasons: total > 0 ? [reason] : [reason], known: 0, total };
+}
+export function deriveAttemptWaste(input) {
+    const publishOnly = input.publishOnlySessionIds ?? new Set();
+    const usageBySession = new Map(input.usages.map((u) => [u.workerSessionId, u]));
+    const boundsBySession = new Map(input.agentBoundaries.map((b) => [b.sessionId, b]));
+    const failed = input.sessions.filter(isWastedSession);
+    const publishOnlyFailed = failed.filter((s) => publishOnly.has(s.id));
+    const agentFailed = failed.filter((s) => !publishOnly.has(s.id));
+    // Runtime: exact agent interval when both boundaries exist, else the inferred
+    // spawn envelope (usage duration includes slot wait + post-exit work, §6.1).
+    const runtimes = [];
+    for (const session of agentFailed) {
+        const bounds = boundsBySession.get(session.id);
+        if (bounds?.startMs != null && bounds?.endMs != null) {
+            if (bounds.endMs < bounds.startMs)
+                continue;
+            runtimes.push({ value: bounds.endMs - bounds.startMs, quality: "exact", reasons: [] });
+            continue;
+        }
+        const duration = usageBySession.get(session.id)?.durationMs;
+        if (duration != null && Number.isFinite(duration)) {
+            runtimes.push({
+                value: duration,
+                quality: "inferred",
+                reasons: ["proxy_boundary", "includes_spawn_slot_wait", "includes_post_exit_work"],
+            });
+        }
+    }
+    const runtimeMs = runtimes.length === 0
+        ? unavailableAggregate(agentFailed.length, "no_defensible_boundary")
+        : withPartialSample({
+            value: runtimes.reduce((sum, r) => sum + r.value, 0),
+            quality: runtimes.some((r) => r.quality === "inferred") ? "inferred" : "exact",
+            reasons: [...new Set(runtimes.flatMap((r) => r.reasons))],
+            known: runtimes.length,
+            total: agentFailed.length,
+        });
+    // Value metrics: provider-recorded numbers only, never coerced from null.
+    const sumKnown = (pick) => {
+        const values = [];
+        for (const session of agentFailed) {
+            const v = usageBySession.get(session.id) ? pick(usageBySession.get(session.id)) : null;
+            if (v != null && Number.isFinite(v))
+                values.push(v);
+        }
+        if (values.length === 0)
+            return unavailableAggregate(agentFailed.length, "missing_provider_metadata");
+        return withPartialSample({
+            value: values.reduce((sum, v) => sum + v, 0),
+            quality: "exact",
+            known: values.length,
+            total: agentFailed.length,
+        });
+    };
+    return {
+        failedAttempts: agentFailed.length,
+        publishOnlyAttempts: publishOnlyFailed.length,
+        runtimeMs,
+        tokensIn: sumKnown((u) => u.tokensIn),
+        tokensOut: sumKnown((u) => u.tokensOut),
+        costUsd: sumKnown((u) => u.costUsd),
+    };
+}
+export function deriveRetrySummary(input) {
+    const reuseBySession = new Map(input.reuse.map((r) => [r.sessionId, r]));
+    const hints = input.hints ?? new Map();
+    const detail = [];
+    for (const session of input.sessions.slice(1)) {
+        const record = reuseBySession.get(session.id);
+        if (record) {
+            detail.push({
+                sessionId: session.id,
+                kinds: record.kinds,
+                cold: record.kinds.length === 0,
+                quality: "exact",
+                reasons: [],
+            });
+            continue;
+        }
+        // Legacy: consume the recovery/routing payload only when defensible.
+        const hint = hints.get(session.id);
+        if (hint?.publishOnly) {
+            detail.push({
+                sessionId: session.id,
+                kinds: ["publish_only"],
+                cold: false,
+                quality: "inferred",
+                reasons: ["backfill"],
+            });
+            continue;
+        }
+        detail.push({
+            sessionId: session.id,
+            kinds: [],
+            cold: null,
+            quality: hint?.retryReason ? "inferred" : "unavailable",
+            reasons: hint?.retryReason ? ["backfill"] : ["missing_reuse_evidence"],
+        });
+    }
+    return {
+        attempts: input.sessions.length,
+        retries: detail.length,
+        cold: detail.filter((d) => d.cold === true).length,
+        reused: detail.filter((d) => d.cold === false).length,
+        unknown: detail.filter((d) => d.cold === null).length,
+        publishOnly: detail.filter((d) => d.kinds.includes("publish_only")).length,
+        attemptsDetail: detail,
+    };
+}
+function parseCheckpointRow(row) {
+    if (!row.payload_json)
+        return null;
+    try {
+        const parsed = CheckpointObservedPayload.safeParse(JSON.parse(row.payload_json));
+        if (!parsed.success)
+            return null;
+        return {
+            sessionId: row.worker_session_id,
+            kind: parsed.data.kind,
+            observedSha: parsed.data.observedSha,
+            observedAt: parsed.data.observedAt,
+            origin: parsed.data.origin,
+            inputSha: parsed.data.inputSha,
+            samplingPrecisionMs: parsed.data.samplingPrecisionMs,
+            branch: parsed.data.branch,
+            ts: row.ts,
+            cursor: row.cursor,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** All checkpoint evidence for an issue, in durable (ts, cursor) order. */
+export function listCheckpointsForIssue(issueId) {
+    const rows = getDb()
+        .prepare(`SELECT rowid AS cursor, ts, worker_session_id, payload_json FROM workflow_events
+       WHERE issue_id = ? AND type = 'checkpoint.observed'
+       ORDER BY ts ASC, rowid ASC`)
+        .all(issueId);
+    return rows
+        .map(parseCheckpointRow)
+        .filter((r) => r !== null);
+}
+/** The reuse record for one retry session, or null when none was recorded. */
+export function getRetryReuseForSession(workerSessionId) {
+    const row = getDb()
+        .prepare(`SELECT rowid AS cursor, ts, worker_session_id, payload_json FROM workflow_events
+       WHERE worker_session_id = ? AND type = 'retry.reused'
+       ORDER BY rowid ASC LIMIT 1`)
+        .get(workerSessionId);
+    if (!row?.payload_json || !row.worker_session_id)
+        return null;
+    try {
+        const parsed = RetryReusedPayload.safeParse(JSON.parse(row.payload_json));
+        if (!parsed.success)
+            return null;
+        return {
+            sessionId: row.worker_session_id,
+            kinds: parsed.data.kinds,
+            retryReason: parsed.data.retryReason,
+            ts: row.ts,
+            cursor: row.cursor,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** All reuse records for an issue, in durable (ts, cursor) order. */
+export function listReuseForIssue(issueId) {
+    const rows = getDb()
+        .prepare(`SELECT rowid AS cursor, ts, worker_session_id, payload_json FROM workflow_events
+       WHERE issue_id = ? AND type = 'retry.reused'
+       ORDER BY ts ASC, rowid ASC`)
+        .all(issueId);
+    const out = [];
+    for (const row of rows) {
+        if (!row.payload_json || !row.worker_session_id)
+            continue;
+        try {
+            const parsed = RetryReusedPayload.safeParse(JSON.parse(row.payload_json));
+            if (!parsed.success)
+                continue;
+            out.push({
+                sessionId: row.worker_session_id,
+                kinds: parsed.data.kinds,
+                retryReason: parsed.data.retryReason,
+                ts: row.ts,
+                cursor: row.cursor,
+            });
+        }
+        catch {
+            // malformed evidence never drives metrics
+        }
+    }
+    return out;
+}
+/** Exact agent-process boundaries per session from durable agent.* events. */
+export function listAgentBoundariesForIssue(issueId) {
+    const rows = getDb()
+        .prepare(`SELECT worker_session_id AS sessionId, type, ts FROM workflow_events
+       WHERE issue_id = ? AND type IN ('agent.started', 'agent.completed')
+       ORDER BY ts ASC, rowid ASC`)
+        .all(issueId);
+    const starts = new Map();
+    const ends = new Map();
+    for (const row of rows) {
+        if (!row.sessionId)
+            continue;
+        const ms = msOf(row.ts);
+        if (ms === null)
+            continue;
+        if (row.type === "agent.started" && !starts.has(row.sessionId))
+            starts.set(row.sessionId, ms);
+        if (row.type === "agent.completed" && !ends.has(row.sessionId))
+            ends.set(row.sessionId, ms);
+    }
+    const ids = new Set([...starts.keys(), ...ends.keys()]);
+    return [...ids].map((sessionId) => ({
+        sessionId,
+        startMs: starts.get(sessionId) ?? null,
+        endMs: ends.get(sessionId) ?? null,
+    }));
+}
+/** Sessions that ran the no-agent publish path (worker terminal carries publishOnly). */
+export function listPublishOnlySessionsForIssue(issueId) {
+    const rows = getDb()
+        .prepare(`SELECT worker_session_id AS sessionId, payload_json AS payload FROM workflow_events
+       WHERE issue_id = ? AND type IN ('worker.completed', 'worker.failed')`)
+        .all(issueId);
+    const out = new Set();
+    for (const row of rows) {
+        if (!row.sessionId || !row.payload)
+            continue;
+        try {
+            const payload = JSON.parse(row.payload);
+            if (payload.publishOnly === true)
+                out.add(row.sessionId);
+        }
+        catch {
+            // ignore malformed payloads
+        }
+    }
+    return out;
+}
+/** Per-session work-item payload hints for legacy retry derivation. */
+export function sessionHintsForIssue(issueId) {
+    const rows = getDb()
+        .prepare("SELECT worker_session_id AS sessionId, payload_json AS payload FROM work_items WHERE issue_id = ?")
+        .all(issueId);
+    const out = new Map();
+    for (const row of rows) {
+        if (!row.sessionId)
+            continue;
+        let publishOnly = false;
+        let retryReason = null;
+        if (row.payload) {
+            try {
+                const payload = JSON.parse(row.payload);
+                publishOnly = payload.publishOnly === true;
+                retryReason = typeof payload.retryReason === "string" ? payload.retryReason : null;
+            }
+            catch {
+                // keep defaults
+            }
+        }
+        out.set(row.sessionId, { publishOnly, retryReason });
+    }
+    return out;
+}

package/bundle/server/dist/coordinator/attempt-waste.test.js

@@ -0,0 +1,221 @@
+// packages/server/src/coordinator/attempt-waste.test.ts
+//
+// NOT-172: failed-attempt waste, first checkpoint, and retry-reuse derivation.
+//
+// Pure derivation over durable evidence shapes (no DB): exact agent intervals
+// beat the inferred spawn envelope, null provider fields stay null with
+// known/total counts, publish-only attempts add zero agent waste but remain
+// retries, and legacy payloads derive only as inferred.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { deriveAttemptWaste, deriveFirstCheckpoint, deriveRetrySummary, isWastedSession, } from "./attempt-waste.js";
+const T0 = "2026-09-21T00:00:00.000Z";
+const T1 = "2026-09-21T00:05:00.000Z";
+const T2 = "2026-09-21T00:10:00.000Z";
+function session(overrides) {
+    return {
+        role: "developer",
+        status: "failed",
+        errorJson: null,
+        createdAt: T0,
+        ...overrides,
+    };
+}
+function checkpoint(overrides = {}) {
+    return {
+        sessionId: "session-1",
+        kind: "commit",
+        observedSha: "a".repeat(40),
+        observedAt: T1,
+        origin: "sampler",
+        inputSha: "b".repeat(40),
+        samplingPrecisionMs: 10_000,
+        branch: "issue-1",
+        ts: T1,
+        cursor: 7,
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------- first checkpoint
+test("first checkpoint reports ms since workflow start as exact", () => {
+    const first = deriveFirstCheckpoint({ workflowStartedAt: T0, checkpoints: [checkpoint()] });
+    assert.equal(first.kind, "commit");
+    assert.equal(first.msSinceWorkflowStart, 5 * 60_000);
+    assert.equal(first.quality, "exact");
+    assert.deepEqual(first.reasons, []);
+});
+test("earliest of several checkpoints wins by (ts, cursor) order", () => {
+    const first = deriveFirstCheckpoint({
+        workflowStartedAt: T0,
+        checkpoints: [
+            checkpoint({ observedAt: T2, ts: T2, cursor: 9, kind: "branch_pushed" }),
+            checkpoint({ observedAt: T1, ts: T1, cursor: 7, kind: "commit" }),
+        ],
+    });
+    assert.equal(first.kind, "commit");
+    assert.equal(first.msSinceWorkflowStart, 5 * 60_000);
+});
+test("no checkpoints and no legacy evidence is unavailable, never zero", () => {
+    const first = deriveFirstCheckpoint({ workflowStartedAt: T0, checkpoints: [] });
+    assert.equal(first.msSinceWorkflowStart, null);
+    assert.equal(first.quality, "unavailable");
+    assert.ok(first.reasons.includes("missing_checkpoint"));
+});
+test("legacy evidence derives an inferred first checkpoint, never exact", () => {
+    const first = deriveFirstCheckpoint({ workflowStartedAt: T0, checkpoints: [], legacyFirstEvidenceAt: T2 });
+    assert.equal(first.msSinceWorkflowStart, 10 * 60_000);
+    assert.equal(first.quality, "inferred");
+    assert.ok(first.reasons.includes("backfill"));
+});
+test("a checkpoint before workflow start is a negative duration, not clamped", () => {
+    const first = deriveFirstCheckpoint({ workflowStartedAt: T2, checkpoints: [checkpoint()] });
+    assert.equal(first.msSinceWorkflowStart, null);
+    assert.equal(first.quality, "unavailable");
+    assert.ok(first.reasons.includes("negative_duration"));
+});
+// --------------------------------------------------------------- waste scope
+test("failed and timed_out count as waste; done never does", () => {
+    assert.equal(isWastedSession(session({ id: "a", status: "failed" })), true);
+    assert.equal(isWastedSession(session({ id: "b", status: "timed_out" })), true);
+    assert.equal(isWastedSession(session({ id: "c", status: "done" })), false);
+    assert.equal(isWastedSession(session({ id: "d", status: "queued" })), false);
+    assert.equal(isWastedSession(session({ id: "e", status: "running" })), false);
+});
+test("cancelled counts only with failure evidence", () => {
+    assert.equal(isWastedSession(session({ id: "a", status: "cancelled", errorJson: JSON.stringify({ reason: "boom" }) })), true);
+    assert.equal(isWastedSession(session({ id: "b", status: "cancelled", errorJson: null })), false);
+});
+// ------------------------------------------------------------------ waste sums
+function usage(overrides) {
+    return { tokensIn: null, tokensOut: null, costUsd: null, durationMs: null, ...overrides };
+}
+test("a failed session followed by success reports the first attempt as waste", () => {
+    const waste = deriveAttemptWaste({
+        sessions: [
+            session({ id: "s1", status: "failed" }),
+            session({ id: "s2", status: "done" }),
+        ],
+        usages: [
+            usage({ workerSessionId: "s1", tokensIn: 100, tokensOut: 50, costUsd: 0.42, durationMs: 60_000 }),
+            usage({ workerSessionId: "s2", tokensIn: 200, tokensOut: 60, costUsd: 0.5, durationMs: 70_000 }),
+        ],
+        agentBoundaries: [],
+    });
+    assert.equal(waste.failedAttempts, 1);
+    // No agent boundaries: the spawn envelope stands in, marked inferred.
+    assert.equal(waste.runtimeMs.value, 60_000);
+    assert.equal(waste.runtimeMs.quality, "inferred");
+    assert.ok(waste.runtimeMs.reasons.includes("includes_spawn_slot_wait"));
+    assert.ok(waste.runtimeMs.reasons.includes("includes_post_exit_work"));
+    assert.equal(waste.tokensIn.value, 100);
+    assert.equal(waste.tokensIn.quality, "exact");
+    assert.equal(waste.costUsd.value, 0.42);
+});
+test("exact agent intervals beat the usage envelope when both exist", () => {
+    const start = Date.parse(T0);
+    const bounds = [{ sessionId: "s1", startMs: start, endMs: start + 45_000 }];
+    const waste = deriveAttemptWaste({
+        sessions: [session({ id: "s1", status: "timed_out" })],
+        usages: [usage({ workerSessionId: "s1", durationMs: 60_000 })],
+        agentBoundaries: bounds,
+    });
+    assert.equal(waste.runtimeMs.value, 45_000);
+    assert.equal(waste.runtimeMs.quality, "exact");
+    assert.deepEqual(waste.runtimeMs.reasons, []);
+});
+test("missing provider fields stay unavailable with coverage counts, never zero", () => {
+    const waste = deriveAttemptWaste({
+        sessions: [session({ id: "s1" }), session({ id: "s2", status: "timed_out" })],
+        usages: [
+            // Cursor-style row: tokens known, cost never reported.
+            usage({ workerSessionId: "s1", tokensIn: 100, tokensOut: 50, costUsd: null, durationMs: 60_000 }),
+            usage({ workerSessionId: "s2", tokensIn: null, tokensOut: null, costUsd: null, durationMs: null }),
+        ],
+        agentBoundaries: [],
+    });
+    assert.equal(waste.tokensIn.value, 100);
+    assert.equal(waste.tokensIn.known, 1);
+    assert.equal(waste.tokensIn.total, 2);
+    assert.ok(waste.tokensIn.reasons.includes("partial_sample"));
+    assert.equal(waste.costUsd.value, null);
+    assert.equal(waste.costUsd.quality, "unavailable");
+    assert.equal(waste.costUsd.known, 0);
+    assert.equal(waste.costUsd.total, 2);
+    assert.ok(waste.costUsd.reasons.includes("missing_provider_metadata"));
+    // Runtime known for one of two — partial, still summed over known only.
+    assert.equal(waste.runtimeMs.value, 60_000);
+    assert.equal(waste.runtimeMs.known, 1);
+    assert.equal(waste.runtimeMs.total, 2);
+});
+test("no failed attempts is unavailable across the board, never zero waste presented as exact", () => {
+    const waste = deriveAttemptWaste({
+        sessions: [session({ id: "s1", status: "done" })],
+        usages: [usage({ workerSessionId: "s1", tokensIn: 1, costUsd: 0.01, durationMs: 5 })],
+        agentBoundaries: [],
+    });
+    assert.equal(waste.failedAttempts, 0);
+    for (const agg of [waste.runtimeMs, waste.tokensIn, waste.tokensOut, waste.costUsd]) {
+        assert.equal(agg.value, null);
+        assert.equal(agg.quality, "unavailable");
+    }
+});
+test("coordinator-only publish retries add zero agent waste but remain attempts", () => {
+    const waste = deriveAttemptWaste({
+        sessions: [session({ id: "s1" }), session({ id: "s2", status: "done" })],
+        usages: [usage({ workerSessionId: "s1", tokensIn: 999, tokensOut: 999, costUsd: 9.99, durationMs: 999_999 })],
+        agentBoundaries: [{ sessionId: "s1", startMs: 1, endMs: 999_999 }],
+        publishOnlySessionIds: new Set(["s1"]),
+    });
+    assert.equal(waste.failedAttempts, 0, "publish-only is not an agent failure");
+    assert.equal(waste.publishOnlyAttempts, 1);
+    // Its rows/bounds are structurally excluded — not counted as missing either.
+    assert.equal(waste.tokensIn.total, 0);
+    assert.equal(waste.runtimeMs.total, 0);
+});
+// ------------------------------------------------------------- retry summary
+test("cold retries are distinguishable from reused-work retries", () => {
+    const summary = deriveRetrySummary({
+        sessions: [session({ id: "s1", status: "failed" }), session({ id: "s2" }), session({ id: "s3" })],
+        reuse: [
+            { sessionId: "s2", kinds: ["worktree", "commit"], retryReason: "retry", ts: T1, cursor: 3 },
+            { sessionId: "s3", kinds: [], retryReason: "retry", ts: T2, cursor: 5 },
+        ],
+    });
+    assert.equal(summary.attempts, 2 + 1);
+    assert.equal(summary.retries, 2);
+    assert.equal(summary.reused, 1);
+    assert.equal(summary.cold, 1);
+    assert.equal(summary.unknown, 0);
+    assert.deepEqual(summary.attemptsDetail[0].kinds, ["worktree", "commit"]);
+    assert.equal(summary.attemptsDetail[0].cold, false);
+    assert.equal(summary.attemptsDetail[1].cold, true);
+});
+test("a retry with no reuse record is unknown, not cold", () => {
+    const summary = deriveRetrySummary({
+        sessions: [session({ id: "s1" }), session({ id: "s2" })],
+        reuse: [],
+    });
+    assert.equal(summary.retries, 1);
+    assert.equal(summary.cold, 0);
+    assert.equal(summary.unknown, 1);
+    assert.equal(summary.attemptsDetail[0].cold, null);
+    assert.equal(summary.attemptsDetail[0].quality, "unavailable");
+});
+test("legacy payloads derive publish_only as inferred, retryReason as unknown", () => {
+    const summary = deriveRetrySummary({
+        sessions: [session({ id: "s1" }), session({ id: "s2" }), session({ id: "s3" })],
+        reuse: [],
+        hints: new Map([
+            ["s2", { publishOnly: true, retryReason: "presumed dead; republishing 1 commit" }],
+            ["s3", { publishOnly: false, retryReason: "Developer session produced no PR." }],
+        ]),
+    });
+    assert.equal(summary.reused, 1);
+    assert.equal(summary.publishOnly, 1);
+    assert.equal(summary.unknown, 1);
+    assert.deepEqual(summary.attemptsDetail[0].kinds, ["publish_only"]);
+    assert.equal(summary.attemptsDetail[0].quality, "inferred");
+    assert.ok(summary.attemptsDetail[0].reasons.includes("backfill"));
+    assert.equal(summary.attemptsDetail[1].cold, null);
+    assert.equal(summary.attemptsDetail[1].quality, "inferred");
+});

package/bundle/server/dist/coordinator/checkpoint.js

@@ -0,0 +1,55 @@
+import { appendWorkflowEvent } from "../repository/workflow-events.js";
+import { workerSessionPayload } from "./session-progress.js";
+/**
+ * Record one checkpoint kind for a session — at most once per (session, kind),
+ * except the salvage-origin commit, which is keyed independently so an agent
+ * that commits and then crashes/times out dirty still leaves durable salvage
+ * evidence alongside the earlier observation. First-commit derivation still
+ * counts once: it orders all commit rows and takes the earliest.
+ */
+export function emitCheckpointObserved(ev) {
+    appendWorkflowEvent({
+        issueId: ev.issueId,
+        workflowInstanceId: ev.workflowInstanceId,
+        workerSessionId: ev.workerSessionId,
+        type: "checkpoint.observed",
+        actorType: ev.role,
+        stage: ev.stage,
+        round: ev.round,
+        payload: {
+            ...workerSessionPayload({ runtime: null, model: null, sessionId: ev.workerSessionId }),
+            kind: ev.kind,
+            observedSha: ev.observedSha ?? null,
+            observedAt: ev.observedAt ?? new Date().toISOString(),
+            origin: ev.kind === "commit" ? (ev.origin ?? null) : null,
+            inputSha: ev.inputSha ?? null,
+            samplingPrecisionMs: ev.samplingPrecisionMs ?? null,
+            branch: ev.branch ?? null,
+        },
+        idempotencyKey: ev.kind === "commit" && ev.origin === "salvage"
+            ? `checkpoint:${ev.workerSessionId}:commit:salvage`
+            : `checkpoint:${ev.workerSessionId}:${ev.kind}`,
+    });
+}
+/**
+ * Record which prior work a retry/recovery actually reused — exactly once per
+ * session. A cold retry is recorded with an empty kinds array so it stays
+ * distinguishable from "no reuse evidence recorded".
+ */
+export function emitRetryReuse(ev) {
+    appendWorkflowEvent({
+        issueId: ev.issueId,
+        workflowInstanceId: ev.workflowInstanceId,
+        workerSessionId: ev.workerSessionId,
+        type: "retry.reused",
+        actorType: ev.role,
+        stage: ev.stage,
+        round: ev.round,
+        payload: {
+            ...workerSessionPayload({ runtime: null, model: null, sessionId: ev.workerSessionId }),
+            kinds: ev.kinds,
+            retryReason: ev.retryReason ?? null,
+        },
+        idempotencyKey: `retry-reused:${ev.workerSessionId}`,
+    });
+}