@plurnk/plurnk-service 1.7.0 → 1.9.0

package/dist/digest/Digest.js

@@ -6,17 +6,16 @@
 //
 //   test/digest/digest.md           Health triage rollup (clean/degenerate-win/failed loops) +
 //                                   worker-shape header + waterfall (per-loop health verdict; per-turn:
-//                                   status, ⚠ errs=N, model emission summary, indented op list)
+//                                   status, ⚠ errs=N, source-artifact summary, indented op list)
 //   test/digest/digest.json         Same data, machine-queryable
 //   test/digest/reasoning.md        Every provider attempt's reasoning and admission result
 //   test/digest/requiem.md          Out-of-band model audit
 //   test/digest/requiem.json        Exact audit messages, responses, usage, and cost
-//   test/digest/packetNNN.packet.md       Journal-only turn note when no model request exists.
-//   test/digest/packetNNN.system.md       BYTE-FOR-BYTE the system message the LLM
-//                                         received on TURN N (0-based).
+//   test/digest/packetNNN.system.md       BYTE-FOR-BYTE the system message sent
+//                                         when the turn involved a provider.
 //   test/digest/packetNNN.user.md         Same for the user message.
 //   test/digest/packetNNN.response.md      Request-only note when no response was admitted.
-//   test/digest/packetNNN.assistant.md     Model emission (content string).
+//   test/digest/packetNNN.assistant.md     Exact persisted turnOps, regardless of producer.
 //   test/digest/packetNNN.assistantRaw.json  Opaque provider response.
 //   test/digest/packetNNN.attemptNNN.rejected.assistant.md
 //                                          Rejected provider emission.
@@ -25,17 +24,15 @@
 //   test/digest/packetNNN.attemptNNN.rejected.parse-errors.json
 //                                          Admission errors for that attempt.
 //
-// packet files are byte-identical to what Engine emits, because Engine and
-// digest both project through PacketWire (one renderer, no drift).
+// Provider request slots are byte-identical to what Engine emits because both
+// paths project through PacketWire. Assistant files preserve durable turnOps.
 //
 // SQL lives in the co-located digest.sql; opened the sqlrite way (SqlRiteSync,
 // the sync CLI/script facade). Each PREP block is read through its own accessor.
-import { DatabaseSync } from "node:sqlite";
 import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 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";
@@ -43,7 +40,9 @@ 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 EntryManifest from "../schemes/_entry-manifest.js";
 import ProviderInstantiate from "../core/ProviderInstantiate.js";
+import HostPaths from "../core/HostPaths.js";
 import { aggregateProviderAccounting, ProviderError, validateProviderRequestAccounting, } from "@plurnk/plurnk-providers";
 import { providerRequestFromStorageRow, } from "../core/provider-accounting.js";
 import { Validator, } from "@plurnk/plurnk-contracts";
@@ -122,7 +121,7 @@ export default class Digest {
         return providerRequestFromStorageRow(row);
     }
     static #accounting(rows) {
-        return rows.some((row) => row.state !== "settled")
+        return rows.length === 0 || rows.some((row) => row.state !== "settled")
             ? null
             : aggregateProviderAccounting(rows.map((row) => Digest.#requestAccounting(row)));
     }
@@ -166,7 +165,7 @@ export default class Digest {
         const stream = Digest.#parseJson(le.attrs, {}).stream;
         return typeof stream === "string" ? stream : null;
     }
-    static #renderOpLine(le, label = le.op ?? "model emission") {
+    static #renderOpLine(le, label = le.op ?? "source artifact") {
         const target = Digest.#renderTarget(le) ?? "—";
         const stream = Digest.#renderStream(le);
         const state = le.state !== "resolved" ? ` state=${le.state}` : "";
@@ -184,12 +183,12 @@ 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 materialized = row.origin === "_plurnk" && row.op === "EDIT" && attrs.kind === "entry_materialized";
         const actionlessKind = row.op === null
             ? LogBody.actionlessKind({ op: row.op, attrs })
             : null;
-        const label = actionlessKind === "model_emission"
-            ? "model emission"
+        const label = actionlessKind === "emissionAttempt"
+            ? "emission attempt"
             : actionlessKind ?? row.op ?? "actionless row";
         return Digest.#renderOpLine(row, materialized ? "materialized entry" : label);
     }
@@ -267,9 +266,12 @@ export default class Digest {
         const attemptBadge = attemptConditions.length === 0
             ? ""
             : `  ⚠ ${attemptConditions.join(" ")}/${attempts.length}`;
-        const head = `T${turn.sequence}: status=${turn.status} finish=${finishReason}${rails} model=${model} ${tokens}${cost}${errBadge}${attemptBadge}`;
+        const lifecycle = `T${turn.sequence}: producer=${turn.producer} kind=${turn.kind} status=${turn.status}${turn.completed_at === null ? " state=open" : ""}`;
+        const head = turn.kind === "inference"
+            ? `${lifecycle} finish=${finishReason}${rails} model=${model} ${tokens}${cost}${errBadge}${attemptBadge}`
+            : `${lifecycle}${errBadge}`;
         const summary = packet === null
-            ? "  ↳ model packet: (none)"
+            ? null
             : content.length > 0
                 ? `  ↳ emission: ${Digest.#summarize(content, 100)}`
                 : assistant !== null
@@ -281,19 +283,27 @@ export default class Digest {
             ? `  ↳ reasoning: ${Digest.#summarize(reasoning, 100)}`
             : null;
         const opLines = Digest.#renderOpLines(m.logEntriesByTurn.get(turn.id) ?? []);
-        return [head, summary, ...(reasoningLine ? [reasoningLine] : []), ...opLines].join("\n");
+        return [head, ...(summary ? [summary] : []), ...(reasoningLine ? [reasoningLine] : []), ...opLines].join("\n");
     }
     static #renderWorkerShape(worker, m) {
         // 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 accounting = Digest.#accounting(m.requestsByWorker.get(worker.id) ?? []);
-        const costStr = accounting === null || accounting.costUsd === null ? "unknown" : `$${accounting.costUsd}`;
+        const requests = m.requestsByWorker.get(worker.id) ?? [];
+        const accounting = Digest.#accounting(requests);
+        const usageStr = requests.length === 0
+            ? "no provider requests"
+            : Digest.#usageSummary(accounting);
+        const costStr = requests.length === 0
+            ? "n/a"
+            : 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:     ${Digest.#usageSummary(accounting)}`,
+            `Tokens:     ${usageStr}`,
             `Cost:       ${costStr}`,
             `Op mix:     ${opMix.length > 0 ? opMix : "(no ops)"}`,
         ].join("\n");
@@ -309,11 +319,12 @@ export default class Digest {
         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}`);
+        lines.push(`Semantic:  channels=${m.embeddings.channel_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:");
             for (const row of m.embeddings.dispositions) {
-                lines.push(`  ${row.disposition} ${row.pathname}${row.reason === null ? "" : ` — ${row.reason}`}`);
+                const address = `${EntryManifest.toPath(row.scheme, row.authority, row.pathname)}#${row.channel}`;
+                lines.push(`  ${row.disposition} ${address}${row.reason === null ? "" : ` — ${row.reason}`}`);
             }
         }
         // Triage rollup up top: how many conversations limped vs died vs ran clean, and the total
@@ -368,12 +379,17 @@ export default class Digest {
         const lines = [];
         lines.push(`# plurnk-service reasoning`);
         lines.push("");
-        lines.push("Every provider attempt in turn order. Rejected attempts remain explicit forensic evidence.");
+        lines.push("Turn chronology with every provider attempt. Rejected attempts remain explicit forensic evidence.");
         for (const t of m.turns) {
             const loop = m.loopsById.get(t.loop_id);
             const worker = loop ? m.workersById.get(loop.worker_id) : undefined;
             lines.push("");
-            lines.push(`## Worker ${worker?.id ?? "?"} / Loop ${loop?.sequence ?? "?"} / Turn ${t.sequence} (id=${t.id})`);
+            lines.push(`## Worker ${worker?.id ?? "?"} / Loop ${loop?.sequence ?? "?"} / Turn ${t.sequence} (id=${t.id}, producer=${t.producer}, kind=${t.kind})`);
+            if (t.kind !== "inference") {
+                lines.push("");
+                lines.push("(operation turn; no provider inference)");
+                continue;
+            }
             const attempts = m.attemptsByTurn.get(t.id) ?? [];
             if (attempts.length === 0) {
                 const reasoning = t.packet !== null && StoredPacket.isAdmitted(t.packet)
@@ -419,41 +435,62 @@ export default class Digest {
         }
         return lines.join("\n");
     }
-    // Per-turn packet files, byte-identical to the wire (Engine and digest both
-    // project through PacketWire). system/user are markdown; assistantRaw is JSON.
+    static #turnOpsSource(m, turn) {
+        const rows = (m.logEntriesByTurn.get(turn.id) ?? []).filter((row) => row.op === null
+            && LogBody.actionlessKind({ op: row.op, attrs: row.attrs }) === "turnOps");
+        if (rows.length > 1) {
+            throw new TypeError(`digest: turn ${turn.id} has ${rows.length} turnOps rows; expected at most one`);
+        }
+        const row = rows[0];
+        if (row === undefined)
+            return null;
+        const body = LogBody.resolve({
+            op: row.op,
+            attrs: row.attrs,
+            tx: null,
+            rx: row.rx,
+            mimetypeRx: row.mimetype_rx,
+        });
+        if (body.mimetype !== "text/vnd.plurnk") {
+            throw new TypeError(`digest: turn ${turn.id} turnOps has mimetype ${JSON.stringify(body.mimetype)}; expected text/vnd.plurnk`);
+        }
+        return body.content;
+    }
+    // Per-turn forensic files. turnOps is the source authority; PacketWire
+    // reproduces provider request slots, and assistantRaw preserves provider bytes.
     static #writePacketFiles(m) {
         const written = [];
-        // 0-based TURN index, NOT the DB id. id-sorted so the index is chronological.
-        m.turns.toSorted((a, b) => a.id - b.id).forEach((t, index) => {
-            const packet = t.packet;
-            const padded = String(index).padStart(3, "0");
-            if (packet === null) {
-                const file = `packet${padded}.packet.md`;
-                const note = `# Turn ${index} — no model packet\n\nThis journal-only turn dispatched operations without assembling a model request. See digest.md for its log rows.\n`;
-                writeFileSync(join(m.digestDir, file), note);
-                written.push(file);
-                return;
+        m.turns
+            .map((turn) => ({ turn, source: Digest.#turnOpsSource(m, turn) }))
+            .filter(({ turn, source }) => turn.packet !== null || source !== null)
+            .toSorted((a, b) => a.turn.id - b.turn.id)
+            .forEach(({ turn, source }, ordinal) => {
+            const padded = String(ordinal).padStart(3, "0");
+            const files = [];
+            const packet = turn.packet;
+            if (packet !== null) {
+                files.push([`packet${padded}.system.md`, PacketWire.renderSlot(packet.sections, "system")], [`packet${padded}.user.md`, PacketWire.renderSlot(packet.sections, "user")]);
             }
-            const systemMd = PacketWire.renderSlot(packet.sections, "system");
-            const userMd = PacketWire.renderSlot(packet.sections, "user");
-            const files = [
-                [`packet${padded}.system.md`, systemMd],
-                [`packet${padded}.user.md`, userMd],
-            ];
-            if (StoredPacket.isAdmitted(packet)) {
-                files.push([`packet${padded}.assistant.md`, packet.assistant.content], [`packet${padded}.assistantRaw.json`, JSON.stringify(packet.assistantRaw, null, 2)]);
+            if (source !== null) {
+                files.push([`packet${padded}.assistant.md`, source]);
             }
-            else {
+            if (packet !== null && StoredPacket.isAdmitted(packet)) {
+                if (source !== null && packet.assistant.content !== source) {
+                    throw new TypeError(`digest: turn ${turn.id} packet assistant differs from its turnOps source`);
+                }
+                files.push([`packet${padded}.assistantRaw.json`, JSON.stringify(packet.assistantRaw, null, 2)]);
+            }
+            else if (packet !== null) {
                 files.push([
                     `packet${padded}.response.md`,
-                    `# Turn ${index} — request only\n\nNo provider response was admitted. Rejected attempt evidence, when present, is written separately.\n`,
+                    `# Packet ${ordinal} — request only\n\nNo provider response was admitted. Rejected attempt evidence, when present, is written separately.\n`,
                 ]);
             }
             for (const [file, body] of files) {
                 writeFileSync(join(m.digestDir, file), body);
                 written.push(file);
             }
-            for (const attempt of m.attemptsByTurn.get(t.id) ?? []) {
+            for (const attempt of m.attemptsByTurn.get(turn.id) ?? []) {
                 if (attempt.accepted === 1)
                     continue;
                 const attemptPadded = String(attempt.sequence).padStart(3, "0");
@@ -511,7 +548,9 @@ export default class Digest {
                 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,
+                id: t.id, loop_id: t.loop_id, sequence: t.sequence,
+                producer: t.producer, kind: t.kind,
+                status: t.status, completed_at: t.completed_at,
                 accounting: Digest.#accounting(m.requestsByTurn.get(t.id) ?? []),
                 finish_reason: t.finish_reason, model: t.model,
                 attributions: t.packet?.attributions ?? [],
@@ -579,24 +618,22 @@ 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 }) => ({
+            log_curation_effects: m.curationEffects.map(({ folded_before, folded_after, tags_added, tags_removed, ...effect }) => ({
                 ...effect,
+                folded_before: Digest.#parseJson(folded_before, []),
+                folded_after: Digest.#parseJson(folded_after, []),
                 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
-    // `.env.defaults` floor is `~/.plurnk/plurnk.db`). The old repo-local default broke when
-    // the DB moved to `~/.plurnk`; a no-arg digest now reads the service's actual DB.
+    // Default DB path mirrors the host path contract and an explicit service override.
     static defaultDbPath() {
+        const paths = new HostPaths();
         const env = process.env.PLURNK_SERVICE_DB_PATH;
-        if (env !== undefined && env.length > 0) {
-            if (env === "~")
-                return homedir();
-            return env.startsWith("~/") ? resolve(homedir(), env.slice(2)) : env;
-        }
-        return resolve(homedir(), ".plurnk", "plurnk.db");
+        return env !== undefined && env.length > 0
+            ? resolve(paths.expandUserPath(env))
+            : paths.databaseFile;
     }
     // {§digest-requiem}: one out-of-band audit per model-bearing worker, with exact
     // historical evidence and a required witness provider.
@@ -625,8 +662,9 @@ export default class Digest {
             attempts.push(attempt);
             attemptsByTurn.set(attempt.turn_id, attempts);
         }
-        // Each worker's turns that carry a model request, ordered; the last is
-        // the worker's final context. A worker with only journal turns is silent.
+        // Each worker's inference turns that carry a model request, ordered; the
+        // last is the worker's final context. A worker without inference evidence
+        // is silent.
         const byWorker = new Map();
         for (const t of db.digest_turns.all()) {
             const loop = loopById.get(t.loop_id);
@@ -846,6 +884,17 @@ export default class Digest {
         // mode) inspect cleanly; this tool only reads. The DB is quiescent at
         // digest time, so each PREP reads on its own — no cross-query snapshot.
         const db = new SqlRiteSync({ path: dbPath, dir: [moduleDir] });
+        const tables = new Set(db.digest_schema_tables.all().map(({ name }) => name));
+        const columns = new Map();
+        const has = (table) => tables.has(table);
+        const hasColumn = (table, column) => {
+            let names = columns.get(table);
+            if (names === undefined) {
+                names = new Set(db.digest_schema_columns.all({ table }).map(({ name }) => name));
+                columns.set(table, names);
+            }
+            return names.has(column);
+        };
         let workspaces = db.digest_workspaces.all();
         let workers = db.digest_workers.all();
         let loops = db.digest_loops.all();
@@ -861,50 +910,73 @@ export default class Digest {
         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
-        // specimen may predate token_counts/derivation_embeddings — an old db is a fact to read,
-        // not a contract violation. Absent tables read as -1. node:sqlite directly (SqlRite's
-        // eager prepare would refuse the whole open over one missing optional table).
-        const probe = new DatabaseSync(dbPath, { readOnly: true });
-        const has = (t) => probe.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(t) !== undefined;
-        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");
+        // Historical specimens may predate individual forensic analytics. The
+        // base statement set discovers their schema; only compatible static
+        // SqlRite packs are opened, so absence remains evidence rather than an
+        // eager-prepare failure or a reason to assemble SQL in TypeScript.
+        const channelDerivations = has("entry_channels") && hasColumn("entry_channels", "deep_hash");
+        const legacyEntryDerivations = has("entries") && hasColumn("entries", "deep_hash");
+        const semanticStateAvailable = has("entries") && has("entry_channels")
+            && (channelDerivations || legacyEntryDerivations);
+        const hasDisposition = semanticStateAvailable
+            && has("derivations")
+            && hasColumn("derivations", "disposition");
+        const queryRoot = resolve(moduleDir, "..", "..", "digest-sql");
+        const queryDirs = [
+            ...(has("log_curation_effects") ? [join(queryRoot, "curation")] : []),
+            ...(semanticStateAvailable
+                ? [join(queryRoot, channelDerivations ? "channel-state" : "entry-state")]
+                : []),
+            ...(hasDisposition
+                ? [join(queryRoot, channelDerivations ? "channel-dispositions" : "entry-dispositions")]
+                : []),
+            ...(semanticStateAvailable && has("derivations") ? [join(queryRoot, "derivations")] : []),
+            ...(has("derivation_embeddings") ? [join(queryRoot, "embeddings")] : []),
+            ...(has("token_counts") ? [join(queryRoot, "token-counts")] : []),
+        ];
+        const analytics = queryDirs.length === 0
+            ? null
+            : new SqlRiteSync({ path: dbPath, dir: queryDirs });
         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();
+            curationEffects = analytics.digest_curation_effects.all();
         }
-        const body = semanticStateAvailable
-            ? "FROM entries e JOIN entry_channels ec ON ec.entry_id=e.id AND ec.name='body'"
-            : "";
-        const hasDisposition = has("derivations") && hasColumn("derivations", "disposition");
-        const dispositionCount = (value) => hasDisposition
-            ? one(`SELECT count(*) n ${body} JOIN derivations d ON d.deep_hash=e.deep_hash WHERE d.disposition='${value}'`)
-            : -1;
+        const semanticState = semanticStateAvailable
+            ? (analytics[channelDerivations ? "digest_channel_semantic_state" : "digest_entry_semantic_state"].get()
+                ?? { channel_entries: 0, derivation_complete: 0, unfinished: 0 })
+            : null;
+        const dispositionCounts = hasDisposition
+            ? analytics[channelDerivations ? "digest_channel_disposition_counts" : "digest_entry_disposition_counts"].all()
+            : [];
+        const dispositionCount = (value) => dispositionCounts.find(({ disposition }) => disposition === value)?.n ?? (hasDisposition ? 0 : -1);
         const dispositions = hasDisposition
-            ? probe.prepare(`SELECT e.pathname, d.disposition, d.reason ${body} JOIN derivations d ON d.deep_hash=e.deep_hash WHERE d.disposition <> 'vector' ORDER BY d.disposition, e.pathname`).all()
+            ? analytics[channelDerivations ? "digest_channel_dispositions" : "digest_entry_dispositions"].all()
             : [];
+        const derivationState = semanticStateAvailable && has("derivations")
+            ? analytics.digest_derivation_state.get()
+            : undefined;
+        const embeddingState = has("derivation_embeddings")
+            ? analytics.digest_embedding_state.get()
+            : undefined;
+        const tokenState = has("token_counts")
+            ? analytics.digest_token_count.get()
+            : undefined;
         const embeddings = {
-            body_entries: semanticStateAvailable ? one(`SELECT count(*) n ${body}`) : -1,
-            derivation_complete: semanticStateAvailable ? one(`SELECT count(*) n ${body} WHERE e.deep_hash IS NOT NULL`) : -1,
+            channel_entries: semanticState?.channel_entries ?? -1,
+            derivation_complete: semanticState?.derivation_complete ?? -1,
             vector_complete: dispositionCount("vector"),
             lexical: dispositionCount("lexical"),
             excluded: dispositionCount("excluded"),
             nonsemantic: dispositionCount("nonsemantic"),
             failed: dispositionCount("failed"),
             dispositions,
-            unfinished: semanticStateAvailable ? one(`SELECT count(*) n ${body} WHERE e.deep_hash IS NULL`) : -1,
-            derivation_artifacts_complete: semanticStateAvailable && has("derivations") ? one("SELECT count(*) n FROM derivations WHERE state='complete'") : -1,
-            derivation_artifacts_building: semanticStateAvailable && has("derivations") ? one("SELECT count(*) n FROM derivations WHERE state='building'") : -1,
-            chunk_rows: has("derivation_embeddings") ? one("SELECT count(*) n FROM derivation_embeddings") : -1,
-            models: has("derivation_embeddings") ? one("SELECT count(DISTINCT embedding_model) n FROM derivation_embeddings") : -1,
-            token_derivations: has("token_counts") ? one("SELECT count(*) n FROM token_counts") : -1,
+            unfinished: semanticState?.unfinished ?? -1,
+            derivation_artifacts_complete: derivationState?.complete ?? -1,
+            derivation_artifacts_building: derivationState?.building ?? -1,
+            chunk_rows: embeddingState?.chunks ?? -1,
+            models: embeddingState?.models ?? -1,
+            token_derivations: tokenState?.n ?? -1,
         };
-        probe.close();
+        analytics?.close();
         db.close();
         // {§digest-programmatic-surface} — optional worker/workspace selectors narrow the
         // kept worker graph and its dependent evidence rather than emitting the whole DB.