@plurnk/plurnk-service 1.5.0 → 1.6.1

package/dist/digest/Digest.js

@@ -36,13 +36,16 @@ import { dirname, join, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
+import { isDeepStrictEqual } from "node:util";
 import SqlRiteSync from "@possumtech/sqlrite/sync";
 import { observedSync } from "../observe/spans.js";
 import PacketWire from "../core/packet-wire.js";
+import LogBody from "../core/LogBody.js";
 import StoredPacket from "../core/StoredPacket.js";
 import { renderTarget } from "../core/plurnk-uri.js";
 import ProviderInstantiate from "../core/ProviderInstantiate.js";
-import { ProviderError, providerCostFor, providerCostUsd, validateProviderCost } from "@plurnk/plurnk-providers";
+import { aggregateProviderAccounting, ProviderError, validateProviderRequestAccounting, } from "@plurnk/plurnk-providers";
+import { providerRequestFromStorageRow, } from "../core/provider-accounting.js";
 import { Validator, } from "@plurnk/plurnk-contracts";
 // The requiem prompt ({§digest-requiem}): the model's exit interview. Absolution up front - the system is
 // under test, not the model - so RLHF'd self-blame doesn't crowd out the system indictment. The
@@ -53,7 +56,9 @@ const isRecord = (value) => typeof value === "object" && value !== null && !Arra
 const requiemResponseEvidence = (response) => {
     if (!isRecord(response))
         return response;
-    const { rawBody: _rawBody, ...withoutRawBody } = response;
+    const { rawBody: _rawBody, accounting: _accounting, ...withoutRawBody } = response;
+    void _rawBody;
+    void _accounting;
     if (!isRecord(withoutRawBody.assistantRaw))
         return withoutRawBody;
     const { rawBody: _nestedRawBody, ...assistantRaw } = withoutRawBody.assistantRaw;
@@ -110,20 +115,27 @@ export default class Digest {
             return fallback;
         }
     }
-    static #providerCosts(raw, subject) {
-        const parsed = Digest.#parseJson(raw);
-        if (!Array.isArray(parsed))
-            throw new TypeError(`digest: ${subject} monetary evidence is not an array`);
-        return parsed.map((cost) => validateProviderCost(cost));
-    }
-    static #providerCost(raw, subject) {
-        return validateProviderCost(Digest.#parseJson(raw));
+    static #requestAccounting(row) {
+        if (row.state !== "settled" || row.outcome === null || row.cost_kind === null) {
+            throw new TypeError(`digest: provider request ${row.id} is not settled`);
+        }
+        return providerRequestFromStorageRow(row);
     }
-    static #costProjection(costs) {
-        const values = costs.map(providerCostUsd);
-        return values.some((value) => value === null)
+    static #accounting(rows) {
+        return rows.some((row) => row.state !== "settled")
             ? null
-            : values.reduce((total, value) => total + (value ?? 0), 0);
+            : aggregateProviderAccounting(rows.map((row) => Digest.#requestAccounting(row)));
+    }
+    static #usageSummary(accounting) {
+        if (accounting === null)
+            return "accounting=incomplete";
+        const usage = accounting.usage;
+        return [
+            `input=${usage?.inputTokens ?? "unknown"}`,
+            `output=${usage?.outputTokens ?? "unknown"}`,
+            `reasoning=${usage?.outputTokenDetails?.reasoningTokens ?? "unknown"}`,
+            `cache-read=${usage?.inputTokenDetails?.cacheReadTokens ?? "unknown"}`,
+        ].join(" ");
     }
     static #operationResult(raw, subject) {
         try {
@@ -173,8 +185,13 @@ export default class Digest {
     static #renderGroupedOpLine(row) {
         const attrs = Digest.#parseJson(row.attrs, {});
         const materialized = row.origin === "plurnk" && row.op === "EDIT" && attrs.kind === "entry_materialized";
-        const modelEmission = row.op === null && attrs.kind === "model_emission";
-        return Digest.#renderOpLine(row, materialized ? "materialized entry" : modelEmission ? "model emission" : row.op ?? "actionless row");
+        const actionlessKind = row.op === null
+            ? LogBody.actionlessKind({ op: row.op, attrs })
+            : null;
+        const label = actionlessKind === "model_emission"
+            ? "model emission"
+            : actionlessKind ?? row.op ?? "actionless row";
+        return Digest.#renderOpLine(row, materialized ? "materialized entry" : label);
     }
     // Human triage is not a row dump. Preserve every row in digest.json, but
     // collapse identical rendered outcomes in the Markdown waterfall. Using the
@@ -223,11 +240,11 @@ export default class Digest {
         const assistant = packet !== null && StoredPacket.isAdmitted(packet) ? packet.assistant : null;
         const content = assistant?.content ?? "";
         const reasoning = assistant?.reasoning ?? null;
-        const tokens = `prompt=${turn.usage_prompt} completion=${turn.usage_completion} reasoning=${turn.usage_reasoning} cached=${turn.usage_cached}`;
-        Digest.#providerCosts(turn.usage_cost, `turn ${turn.id}`);
-        const cost = turn.usage_cost_usd === null
+        const accounting = Digest.#accounting(m.requestsByTurn.get(turn.id) ?? []);
+        const tokens = Digest.#usageSummary(accounting);
+        const cost = accounting === null || accounting.costUsd === null
             ? " cost=unavailable"
-            : ` cost=$${turn.usage_cost_usd.toFixed(6)}`;
+            : ` cost=$${accounting.costUsd}`;
         const finishReason = turn.finish_reason ?? "—";
         // Render only observed constraint metadata; absence makes no claim
         // about endpoint-owned settings. {§rail-truth-engine-verdict}
@@ -270,13 +287,14 @@ export default class Digest {
         // every worker has exactly one rollup row — digest_worker_rollups is FROM workers
         const roll = m.workerRollups.get(worker.id);
         const opMix = (m.opMixByWorker.get(worker.id) ?? []).map((o) => `${o.op}=${o.n}`).join(" ");
-        const costStr = roll.total_cost_usd === null ? "unknown" : `$${roll.total_cost_usd.toFixed(6)}`;
+        const accounting = Digest.#accounting(m.requestsByWorker.get(worker.id) ?? []);
+        const costStr = accounting === null || accounting.costUsd === null ? "unknown" : `$${accounting.costUsd}`;
         return [
             `Loops:      ${roll.loops}`,
             `Turns:      ${roll.turns}`,
             `Last turn:  ${roll.last_status !== null ? `status=${roll.last_status}` : "(none)"}`,
-            `Tokens:     prompt=${roll.total_prompt} completion=${roll.total_completion} reasoning=${roll.total_reasoning} cached=${roll.total_cached}`,
-            `Cost:       ${costStr} (DB rollup workers.cost_usd=${worker.cost_usd})`,
+            `Tokens:     ${Digest.#usageSummary(accounting)}`,
+            `Cost:       ${costStr}`,
             `Op mix:     ${opMix.length > 0 ? opMix : "(no ops)"}`,
         ].join("\n");
     }
@@ -286,9 +304,11 @@ export default class Digest {
         lines.push("");
         lines.push(`DB: ${m.dbPath}`);
         const rejectedAttempts = m.turnAttempts.filter((attempt) => attempt.accepted === 0).length;
-        const erroredAttempts = m.turnAttempts.filter((attempt) => attempt.state === "error").length;
-        const pendingAttempts = m.turnAttempts.filter((attempt) => attempt.state === "pending").length;
-        lines.push(`Workspaces: ${m.workspaces.length}  Workers: ${m.workers.length}  Loops: ${m.loops.length}  Turns: ${m.turns.length}  Provider attempts: ${m.turnAttempts.length} (${rejectedAttempts} rejected, ${erroredAttempts} errored, ${pendingAttempts} open)  Log entries: ${m.logEntries.length}`);
+        const erroredCalls = m.modelCalls.filter((call) => call.state === "error").length;
+        const pendingCalls = m.modelCalls.filter((call) => call.state === "pending").length;
+        const bareCalls = m.modelCalls.filter((call) => call.kind === "bare").length;
+        const pendingRequests = m.providerRequests.filter((request) => request.state === "pending").length;
+        lines.push(`Workspaces: ${m.workspaces.length}  Workers: ${m.workers.length}  Loops: ${m.loops.length}  Turns: ${m.turns.length}  Model calls: ${m.modelCalls.length} (${bareCalls} BARE, ${erroredCalls} errored, ${pendingCalls} open)  Emission attempts: ${m.turnAttempts.length} (${rejectedAttempts} rejected)  Provider requests: ${m.providerRequests.length} (${pendingRequests} open)  Log entries: ${m.logEntries.length}`);
         lines.push(`Semantic:  body=${m.embeddings.body_entries} attached=${m.embeddings.derivation_complete} (vector=${m.embeddings.vector_complete} lexical=${m.embeddings.lexical} excluded=${m.embeddings.excluded} nonsemantic=${m.embeddings.nonsemantic} failed=${m.embeddings.failed}) unattached=${m.embeddings.unfinished} artifacts=${m.embeddings.derivation_artifacts_complete} complete/${m.embeddings.derivation_artifacts_building} building chunks=${m.embeddings.chunk_rows} models=${m.embeddings.models} token-derivations=${m.embeddings.token_derivations}`);
         if (m.embeddings.dispositions.length > 0) {
             lines.push("Semantic dispositions:");
@@ -472,59 +492,86 @@ export default class Digest {
         return JSON.stringify({
             dbPath: m.dbPath,
             semantic: m.embeddings,
-            workspaces: m.workspaces.map((s) => ({ id: s.id, name: s.name, cost_usd: s.cost_usd })),
-            workers: m.workers.map((r) => ({ id: r.id, workspace_id: r.workspace_id, name: r.name, cost_usd: r.cost_usd })),
+            workspaces: m.workspaces.map((s) => ({
+                id: s.id,
+                name: s.name,
+                accounting: Digest.#accounting(m.requestsByWorkspace.get(s.id) ?? []),
+            })),
+            workers: m.workers.map((r) => ({
+                id: r.id,
+                workspace_id: r.workspace_id,
+                name: r.name,
+                accounting: Digest.#accounting(m.requestsByWorker.get(r.id) ?? []),
+            })),
             loops: m.loops.map((l) => ({
                 id: l.id, worker_id: l.worker_id, sequence: l.sequence, status: l.status,
                 prompt: l.prompt, flags: Digest.#parseJson(l.flags, {}),
                 terminated_by: l.terminated_by,
                 result: Digest.#terminalResult(l),
+                accounting: Digest.#accounting(m.requestsByLoop.get(l.id) ?? []),
+            })),
+            turns: m.turns.map((t) => ({
+                id: t.id, loop_id: t.loop_id, sequence: t.sequence, status: t.status,
+                accounting: Digest.#accounting(m.requestsByTurn.get(t.id) ?? []),
+                finish_reason: t.finish_reason, model: t.model,
+                attributions: t.packet?.attributions ?? [],
+                // Preserve the opaque provider and engine metadata for aggregate
+                // tooling. {§meta-passthrough}, {§rail-truth-engine-verdict}
+                meta: Digest.#parseJson(t.meta ?? "null", null),
+            })),
+            model_calls: m.modelCalls.map((call) => ({
+                id: call.id,
+                turn_id: call.turn_id,
+                sequence: call.sequence,
+                kind: call.kind,
+                state: call.state,
+                response: Digest.#parseJson(call.response),
+                failure: Digest.#parseJson(call.failure),
+                attributions: Digest.#parseJson(call.attributions, []),
+                accounting: Digest.#accounting(m.requestsByModelCall.get(call.id) ?? []),
+                finish_reason: call.finish_reason,
+                model: call.model,
+                timestamp: call.timestamp,
+                completed_at: call.completed_at,
+                turn_attempt_id: call.turn_attempt_id,
+                accepted: call.accepted === null ? null : call.accepted === 1,
+                parse_errors: Digest.#parseJson(call.parse_errors, []),
+                log_entry_id: call.log_entry_id,
+            })),
+            turn_attempts: m.turnAttempts.map((attempt) => ({
+                id: attempt.id,
+                turn_id: attempt.turn_id,
+                sequence: attempt.sequence,
+                state: attempt.state,
+                accepted: attempt.accepted === null ? null : attempt.accepted === 1,
+                response: Digest.#parseJson(attempt.response),
+                failure: Digest.#parseJson(attempt.failure),
+                parse_errors: Digest.#parseJson(attempt.parse_errors, []),
+                attributions: Digest.#parseJson(attempt.attributions, []),
+                accounting: Digest.#accounting(m.requestsByAttempt.get(attempt.id) ?? []),
+                finish_reason: attempt.finish_reason,
+                model: attempt.model,
+                timestamp: attempt.timestamp,
+                completed_at: attempt.completed_at,
+            })),
+            provider_requests: m.providerRequests.map((request) => ({
+                id: request.id,
+                model_call_id: request.model_call_id,
+                turn_attempt_id: request.turn_attempt_id,
+                kind: request.kind,
+                sequence: request.sequence,
+                state: request.state,
+                accounting: request.state === "settled"
+                    ? Digest.#requestAccounting(request)
+                    : null,
+                started_at: request.started_at,
+                completed_at: request.completed_at,
             })),
-            turns: m.turns.map((t) => {
-                const costs = Digest.#providerCosts(t.usage_cost, `turn ${t.id}`);
-                return {
-                    id: t.id, loop_id: t.loop_id, sequence: t.sequence, status: t.status,
-                    usage_prompt: t.usage_prompt, usage_completion: t.usage_completion,
-                    usage_reasoning: t.usage_reasoning, usage_cached: t.usage_cached,
-                    usage_cost: costs,
-                    usage_cost_usd: t.usage_cost_usd,
-                    finish_reason: t.finish_reason, model: t.model,
-                    attributions: t.packet?.attributions ?? [],
-                    // Preserve the opaque provider and engine metadata for aggregate
-                    // tooling. {§meta-passthrough}, {§rail-truth-engine-verdict}
-                    meta: Digest.#parseJson(t.meta ?? "null", null),
-                };
-            }),
-            turn_attempts: m.turnAttempts.map((attempt) => {
-                const cost = attempt.usage_cost === null
-                    ? null
-                    : Digest.#providerCost(attempt.usage_cost, `attempt ${attempt.id}`);
-                return {
-                    id: attempt.id,
-                    turn_id: attempt.turn_id,
-                    sequence: attempt.sequence,
-                    state: attempt.state,
-                    accepted: attempt.accepted === null ? null : attempt.accepted === 1,
-                    response: Digest.#parseJson(attempt.response),
-                    failure: Digest.#parseJson(attempt.failure),
-                    parse_errors: Digest.#parseJson(attempt.parse_errors, []),
-                    attributions: Digest.#parseJson(attempt.attributions, []),
-                    usage_prompt: attempt.usage_prompt,
-                    usage_completion: attempt.usage_completion,
-                    usage_reasoning: attempt.usage_reasoning,
-                    usage_cached: attempt.usage_cached,
-                    usage_cost: cost,
-                    usage_cost_usd: attempt.usage_cost_usd,
-                    finish_reason: attempt.finish_reason,
-                    model: attempt.model,
-                    timestamp: attempt.timestamp,
-                    completed_at: attempt.completed_at,
-                };
-            }),
             log_entries: m.logEntries.map((le) => ({
                 id: le.id, worker_id: le.worker_id, loop_id: le.loop_id,
                 turn_id: le.turn_id, sequence: le.sequence, origin: le.origin,
-                source: le.source, attrs: Digest.#parseJson(le.attrs, {}),
+                source: le.source, model_call_id: le.model_call_id,
+                attrs: Digest.#parseJson(le.attrs, {}),
                 op: le.op, target: Digest.#renderTarget(le),
                 status_rx: le.status_rx, state: le.state, outcome: le.outcome,
                 ...(Digest.#renderStream(le) === null
@@ -532,6 +579,11 @@ export default class Digest {
                     : { stream: Digest.#renderStream(le) }),
                 ...(le.status_rx >= 400 ? { problem: Digest.#rowProblem(le) } : {}),
             })),
+            log_curation_effects: m.curationEffects.map(({ tags_added, tags_removed, ...effect }) => ({
+                ...effect,
+                tags_added: Digest.#parseJson(tags_added, []),
+                tags_removed: Digest.#parseJson(tags_removed, []),
+            })),
         }, null, 2);
     }
     // Default DB path — mirrors the service (`Service.#expandHome(PLURNK_SERVICE_DB_PATH)`; the
@@ -648,33 +700,20 @@ export default class Digest {
                     content: `# Verbatim worker evidence\n\n${JSON.stringify(evidence, null, 2)}\n\n# Audit request\n\n${REQUIEM_PROMPT}`,
                 },
             ];
-            const id = String(worker.id);
+            const id = worker.provider_identity;
             const report = {
                 workerId: worker.id,
                 workerName: worker.name,
                 messages,
                 responses: [],
                 calls: [],
-                usage: { prompt: 0, completion: 0, reasoning: 0, cached: 0, total: 0 },
-                costs: [],
-                costUsd: null,
+                accounting: aggregateProviderAccounting([]),
                 testimony: null,
             };
             reports.push(report);
             const updateObservedTotals = () => {
-                report.usage = report.calls.reduce((total, call) => {
-                    if (call.usage === null)
-                        return total;
-                    return {
-                        prompt: total.prompt + call.usage.prompt,
-                        completion: total.completion + call.usage.completion,
-                        reasoning: total.reasoning + call.usage.reasoning,
-                        cached: total.cached + call.usage.cached,
-                        total: total.total + call.usage.total,
-                    };
-                }, { prompt: 0, completion: 0, reasoning: 0, cached: 0, total: 0 });
-                report.costs = report.calls.map((call) => call.cost);
-                report.costUsd = Digest.#costProjection(report.costs);
+                const requests = report.calls.flatMap((call) => call.requests.flatMap((request) => request.accounting === null ? [] : [request.accounting]));
+                report.accounting = aggregateProviderAccounting(requests);
                 persistReports();
             };
             const issue = async (outputTokens) => {
@@ -682,25 +721,62 @@ export default class Digest {
                     openedAt: new Date().toISOString(),
                     completedAt: null,
                     state: "open",
-                    usage: null,
-                    cost: { kind: "unknown", reason: "requiem provider call is open" },
+                    requests: [],
                     failure: null,
                 };
                 report.calls.push(call);
                 updateObservedTotals();
+                const observeRequest = async (identity) => {
+                    if (identity.provider.length === 0 || identity.model.length === 0) {
+                        throw new TypeError("requiem provider request identity is incomplete");
+                    }
+                    const request = {
+                        provider: identity.provider,
+                        model: identity.model,
+                        openedAt: new Date().toISOString(),
+                        completedAt: null,
+                        state: "open",
+                        accounting: null,
+                    };
+                    call.requests.push(request);
+                    updateObservedTotals();
+                    return async (value) => {
+                        if (request.state !== "open")
+                            throw new Error("requiem provider request settled more than once");
+                        const accounting = validateProviderRequestAccounting(value);
+                        if (accounting.provider !== identity.provider || accounting.model !== identity.model) {
+                            throw new TypeError("requiem provider request settlement changed its identity");
+                        }
+                        request.state = "settled";
+                        request.completedAt = new Date().toISOString();
+                        request.accounting = accounting;
+                        updateObservedTotals();
+                    };
+                };
+                const assertObserved = (expected) => {
+                    const observedRequests = call.requests.map((request) => {
+                        if (request.accounting === null) {
+                            throw new TypeError("requiem provider returned while a physical request remained open");
+                        }
+                        return request.accounting;
+                    });
+                    if (!isDeepStrictEqual(expected.map(validateProviderRequestAccounting), observedRequests)) {
+                        throw new TypeError("requiem provider accounting differs from its observed physical requests");
+                    }
+                };
                 try {
                     const response = await provider.generate({
                         messages,
                         workerId: id,
                         primaryWorkerId: id,
-                        maxTokens: outputTokens,
+                        maxOutputTokens: outputTokens,
+                        observeRequest,
                         ...(opts.signal !== undefined ? { signal: opts.signal } : {}),
                     });
+                    assertObserved(response.accounting);
                     call.state = "response";
                     call.completedAt = new Date().toISOString();
-                    call.usage = response.assistant.usage;
-                    call.cost = providerCostFor(provider, response.assistant.usage, response.charge);
-                    report.responses.push(response);
+                    report.responses.push(requiemResponseEvidence(response));
                     updateObservedTotals();
                     return response;
                 }
@@ -712,16 +788,11 @@ export default class Digest {
                         : cause instanceof Error
                             ? { name: cause.name, message: cause.message }
                             : String(cause);
-                    if (cause instanceof ProviderError && cause.attempt !== undefined) {
-                        call.usage = cause.attempt.assistant.usage;
-                        call.cost = providerCostFor(provider, cause.attempt.assistant.usage, cause.attempt.charge);
-                        report.responses.push(cause.attempt);
-                    }
-                    else {
-                        call.cost = {
-                            kind: "unknown",
-                            reason: "requiem provider call failed without response-bearing charge evidence",
-                        };
+                    if (cause instanceof ProviderError) {
+                        assertObserved(cause.accounting);
+                        if (cause.attempt !== undefined) {
+                            report.responses.push(requiemResponseEvidence(cause.attempt));
+                        }
                     }
                     updateObservedTotals();
                     throw cause;
@@ -743,13 +814,14 @@ export default class Digest {
             if (resp === undefined)
                 throw new Error(`requiem worker ${worker.id} completed without a provider response`);
             const testimony = resp.assistant.content.trim()
-                || `(no testimony - ${resp.assistant.usage.completion} visible completion tokens after ${report.calls.length} provider attempt(s))`;
+                || `(no testimony - ${report.accounting.usage?.outputTokens ?? "unknown"} output tokens after ${report.calls.length} provider call(s))`;
             report.testimony = testimony;
             persistReports();
-            const costSummary = report.costUsd === null
+            const costSummary = report.accounting.costUsd === null
                 ? "cost USD unavailable"
-                : `cost USD ${report.costUsd}`;
-            out.push(`## Worker #${worker.id} - ${worker.name}`, "", `_(${resp.assistant.model}, ${resp.assistant.finishReason ?? "?"}, attempts ${report.calls.length}, prompt ${report.usage.prompt}, completion ${report.usage.completion}, reasoning ${report.usage.reasoning}, cached ${report.usage.cached}, ${costSummary})_`, "", testimony, "");
+                : `cost USD ${report.accounting.costUsd}`;
+            const physicalRequests = report.calls.reduce((total, call) => total + call.requests.length, 0);
+            out.push(`## Worker #${worker.id} - ${worker.name}`, "", `_(${resp.assistant.model}, ${resp.assistant.finishReason ?? "?"}, provider calls ${report.calls.length}, physical requests ${physicalRequests}, ${Digest.#usageSummary(report.accounting)}, ${costSummary})_`, "", testimony, "");
         }
         const path = join(digestDir, "requiem.md");
         writeFileSync(path, out.join("\n"));
@@ -782,8 +854,11 @@ export default class Digest {
             ...turn,
             packet: StoredPacket.parse(turn.packet, `digest turn ${turn.id}`),
         }));
+        let modelCalls = db.digest_model_calls.all();
         let turnAttempts = db.digest_turn_attempts.all();
+        let providerRequests = db.digest_provider_requests.all();
         let logEntries = db.digest_log_entries.all();
+        let curationEffects = [];
         let workerRollupRows = db.digest_worker_rollups.all();
         let opMixRows = db.digest_worker_op_mix.all();
         // The semantic-state analytic (owner ask), feature-detected per table: a HISTORICAL
@@ -795,6 +870,14 @@ export default class Digest {
         const hasColumn = (table, column) => probe.prepare(`SELECT 1 FROM pragma_table_info(?) WHERE name=?`).get(table, column) !== undefined;
         const one = (q) => Number(probe.prepare(q).get().n);
         const semanticStateAvailable = has("entries") && has("entry_channels") && hasColumn("entries", "deep_hash");
+        if (has("log_curation_effects")) {
+            curationEffects = probe.prepare(`
+                SELECT operation_log_entry_id, target_log_entry_id, expanded_before,
+                       tags_added, tags_removed
+                FROM log_curation_effects
+                ORDER BY operation_log_entry_id, target_log_entry_id
+            `).all();
+        }
         const body = semanticStateAvailable
             ? "FROM entries e JOIN entry_channels ec ON ec.entry_id=e.id AND ec.name='body'"
             : "";
@@ -837,8 +920,13 @@ export default class Digest {
             const keptLoopIds = new Set(loops.map((l) => l.id));
             turns = turns.filter((t) => keptLoopIds.has(t.loop_id));
             const keptTurnIds = new Set(turns.map((t) => t.id));
+            modelCalls = modelCalls.filter((call) => keptTurnIds.has(call.turn_id));
             turnAttempts = turnAttempts.filter((attempt) => keptTurnIds.has(attempt.turn_id));
+            providerRequests = providerRequests.filter((request) => keptTurnIds.has(request.turn_id));
             logEntries = logEntries.filter((le) => keptTurnIds.has(le.turn_id));
+            const keptLogEntryIds = new Set(logEntries.map((entry) => entry.id));
+            curationEffects = curationEffects.filter((effect) => keptLogEntryIds.has(effect.operation_log_entry_id)
+                && keptLogEntryIds.has(effect.target_log_entry_id));
             workerRollupRows = workerRollupRows.filter((r) => keptWorkerIds.has(r.worker_id));
             opMixRows = opMixRows.filter((o) => keptWorkerIds.has(o.worker_id));
         }
@@ -870,6 +958,27 @@ export default class Digest {
             arr.push(attempt);
             attemptsByTurn.set(attempt.turn_id, arr);
         }
+        const requestsByModelCall = new Map();
+        const requestsByAttempt = new Map();
+        const requestsByTurn = new Map();
+        const requestsByLoop = new Map();
+        const requestsByWorker = new Map();
+        const requestsByWorkspace = new Map();
+        const appendRequest = (map, id, request) => {
+            const rows = map.get(id) ?? [];
+            rows.push(request);
+            map.set(id, rows);
+        };
+        for (const request of providerRequests) {
+            appendRequest(requestsByModelCall, request.model_call_id, request);
+            if (request.turn_attempt_id !== null) {
+                appendRequest(requestsByAttempt, request.turn_attempt_id, request);
+            }
+            appendRequest(requestsByTurn, request.turn_id, request);
+            appendRequest(requestsByLoop, request.loop_id, request);
+            appendRequest(requestsByWorker, request.worker_id, request);
+            appendRequest(requestsByWorkspace, request.workspace_id, request);
+        }
         const logEntriesByTurn = new Map();
         for (const le of logEntries) {
             const arr = logEntriesByTurn.get(le.turn_id) ?? [];
@@ -886,8 +995,10 @@ export default class Digest {
             opMixByWorker.set(o.worker_id, arr);
         }
         const m = {
-            dbPath, digestDir, workspaces, workers, loops, turns, turnAttempts, logEntries,
-            workersByWorkspace, loopsByWorker, turnsByLoop, attemptsByTurn, logEntriesByTurn, loopsById, workersById,
+            dbPath, digestDir, workspaces, workers, loops, turns, modelCalls, turnAttempts, providerRequests, logEntries, curationEffects,
+            workersByWorkspace, loopsByWorker, turnsByLoop, attemptsByTurn,
+            requestsByModelCall, requestsByAttempt, requestsByTurn, requestsByLoop, requestsByWorker, requestsByWorkspace,
+            logEntriesByTurn, loopsById, workersById,
             workerRollups, opMixByWorker, embeddings,
         };
         writeFileSync(join(digestDir, "digest.md"), Digest.#renderWaterfall(m));
@@ -897,7 +1008,7 @@ export default class Digest {
         const packetIds = [...new Set(packetFiles.map((f) => f.slice(0, f.indexOf("."))))];
         console.log(`digest: wrote ${digestDir}/{digest.md,digest.json,reasoning.md} + ${packetFiles.length} packet section files (${packetIds.join(", ") || "none"})`);
         console.log(`  source: ${dbPath}`);
-        console.log(`  workspaces=${workspaces.length} workers=${workers.length} loops=${loops.length} turns=${turns.length} turn_attempts=${turnAttempts.length} log_entries=${logEntries.length}`);
+        console.log(`  workspaces=${workspaces.length} workers=${workers.length} loops=${loops.length} turns=${turns.length} model_calls=${modelCalls.length} turn_attempts=${turnAttempts.length} provider_requests=${providerRequests.length} log_entries=${logEntries.length} log_curation_effects=${curationEffects.length}`);
     }
 }
 //# sourceMappingURL=Digest.js.map