@pasko70/pibo 3.1.3 → 3.1.4

package/dist/debug/output-integrity.js

@@ -0,0 +1,608 @@
+import { DatabaseSync } from "node:sqlite";
+import { normalizeLimit } from "./sql.js";
+const THINKING_INDEX_SQL = "CASE WHEN json_valid(attributes_json) THEN COALESCE(json_extract(attributes_json, '$.thinkingIndex'), json_extract(attributes_json, '$.contentIndex'), 0) ELSE 0 END";
+const TOOL_CALL_ID_SQL = "CASE WHEN tool_call_id IS NOT NULL THEN tool_call_id WHEN json_valid(attributes_json) THEN json_extract(attributes_json, '$.toolCallId') END";
+const TOOL_ORDINAL_SQL = "CASE WHEN json_valid(attributes_json) THEN COALESCE(json_extract(attributes_json, '$.toolInvocationOrdinal'), 0) ELSE 0 END";
+const COLLISION_KEY_SQL = "CASE WHEN json_valid(attributes_json) THEN json_extract(attributes_json, '$.outputIdempotencyKey') END";
+const RELIABILITY_SESSION_ID_SQL = "CASE WHEN json_valid(payload_json) THEN COALESCE(json_extract(payload_json, '$.piboSessionId'), json_extract(payload_json, '$.state.piboSessionId')) END";
+const RELIABILITY_EVENT_ID_SQL = "CASE WHEN json_valid(payload_json) THEN COALESCE(json_extract(payload_json, '$.eventId'), json_extract(payload_json, '$.state.eventId')) END";
+export function inspectOutputIntegrity(input) {
+    const limit = normalizeLimit(input.limit);
+    const findings = [];
+    const collisionEventKeys = new Set();
+    let turnLifecycleIssues = 0;
+    let thinkingLifecycleIssues = 0;
+    let toolLifecycleIssues = 0;
+    let identityCollisions = 0;
+    let outputKeyReuses = 0;
+    let sessionTraceStatusMismatches = 0;
+    let pendingOutputJobs = 0;
+    let deadOutputJobs = 0;
+    let deadIdentityCollisions = 0;
+    if (input.dataStore.exists) {
+        const db = new DatabaseSync(input.dataStore.path, { readOnly: true });
+        db.exec("BEGIN");
+        try {
+            if (tableExists(db, "event_log")) {
+                const scope = eventScope(input.piboSessionId, input.since, input.before);
+                const lifecycle = lifecycleScope(input.piboSessionId, input.since, input.before);
+                turnLifecycleIssues = countRows(db, `
+					SELECT COUNT(*) AS count FROM (
+						SELECT session_id, event_id
+						FROM event_log
+						WHERE event_id IS NOT NULL
+							AND type IN ('message_started', 'assistant_message', 'message_finished', 'session_error')
+							${lifecycle.whereSql}
+						GROUP BY session_id, event_id
+						HAVING (
+							SUM(type = 'message_started') != 1
+							OR SUM(type IN ('message_finished', 'session_error')) != 1
+							OR (SUM(type = 'message_finished') = 1 AND SUM(type = 'assistant_message') = 0)
+						) ${lifecycle.havingSql}
+					)
+				`, lifecycle.params);
+                thinkingLifecycleIssues = countRows(db, `
+					SELECT COUNT(*) AS count FROM (
+						SELECT session_id, event_id,
+							${THINKING_INDEX_SQL} AS thinking_index
+						FROM event_log
+						WHERE event_id IS NOT NULL
+							AND type IN ('thinking_started', 'thinking_finished')
+							${lifecycle.whereSql}
+						GROUP BY session_id, event_id, thinking_index
+						HAVING (
+							SUM(type = 'thinking_started') != 1
+							OR SUM(type = 'thinking_finished') != 1
+						) ${lifecycle.havingSql}
+					)
+				`, lifecycle.params);
+                toolLifecycleIssues = countRows(db, `
+					SELECT COUNT(*) AS count FROM (
+						SELECT session_id, event_id,
+							${TOOL_CALL_ID_SQL} AS tool_call_id,
+							${TOOL_ORDINAL_SQL} AS tool_invocation_ordinal
+						FROM event_log
+						WHERE event_id IS NOT NULL
+							AND ${TOOL_CALL_ID_SQL} IS NOT NULL
+							AND type IN ('tool_call', 'tool_execution_started', 'tool_execution_finished')
+							${lifecycle.whereSql}
+						GROUP BY session_id, event_id, tool_call_id, tool_invocation_ordinal
+						HAVING (
+							SUM(type = 'tool_call') != 1
+							OR SUM(type = 'tool_execution_started') != 1
+							OR SUM(type = 'tool_execution_finished') != 1
+						) ${lifecycle.havingSql}
+					)
+				`, lifecycle.params);
+                identityCollisions = countRows(db, `
+					SELECT COUNT(*) AS count
+					FROM event_log
+					WHERE type = 'pibo.output.identity_collision' ${scope.sql}
+				`, scope.params);
+                for (const row of queryRows(db, `
+					SELECT DISTINCT session_id AS sessionId, event_id AS eventId
+					FROM event_log
+					WHERE type = 'pibo.output.identity_collision' AND event_id IS NOT NULL ${scope.sql}
+				`, scope.params))
+                    collisionEventKeys.add(`${row.sessionId}\0${row.eventId}`);
+                outputKeyReuses = countRows(db, `
+					WITH output_keys AS (
+						SELECT session_id, event_id, idempotency_key AS output_key, created_at
+						FROM event_log
+						WHERE idempotency_key LIKE 'pibo.output:%' ${scope.sql}
+						UNION ALL
+						SELECT session_id, event_id, ${COLLISION_KEY_SQL} AS output_key, created_at
+						FROM event_log
+						WHERE type = 'pibo.output.identity_collision'
+							AND ${COLLISION_KEY_SQL} IS NOT NULL ${scope.sql}
+					)
+					SELECT COUNT(*) AS count FROM (
+						SELECT output_key FROM output_keys GROUP BY output_key HAVING COUNT(*) > 1
+					)
+				`, [...scope.params, ...scope.params]);
+                if (tableExists(db, "sessions")) {
+                    const traceStatus = sessionTraceStatusSql(input.piboSessionId, input.since, input.before, true);
+                    sessionTraceStatusMismatches = countRows(db, traceStatus.sql, traceStatus.params);
+                }
+                findings.push(...queryRows(db, `
+					SELECT session_id AS sessionId, event_id AS eventId,
+						SUM(type = 'message_started') AS started,
+						SUM(type IN ('message_finished', 'session_error')) AS finished,
+						SUM(type = 'message_finished') AS messageFinished,
+						SUM(type = 'session_error') AS sessionErrors,
+						SUM(type = 'assistant_message') AS assistantMessages,
+						MIN(created_at) AS firstAt, MAX(created_at) AS lastAt
+					FROM event_log
+					WHERE event_id IS NOT NULL
+						AND type IN ('message_started', 'assistant_message', 'message_finished', 'session_error')
+						${lifecycle.whereSql}
+					GROUP BY session_id, event_id
+					HAVING (started != 1 OR finished != 1 OR (messageFinished = 1 AND assistantMessages = 0)) ${lifecycle.havingSql}
+					ORDER BY lastAt DESC
+					LIMIT ?
+				`, [...lifecycle.params, limit]).map((row) => ({
+                    kind: "turn_lifecycle",
+                    piboSessionId: row.sessionId,
+                    eventId: row.eventId,
+                    firstAt: row.firstAt,
+                    lastAt: row.lastAt,
+                    started: row.started,
+                    finished: row.finished,
+                    messageFinished: row.messageFinished,
+                    sessionErrors: row.sessionErrors,
+                    assistantMessages: row.assistantMessages,
+                })));
+                findings.push(...queryRows(db, `
+					SELECT session_id AS sessionId, event_id AS eventId,
+						${THINKING_INDEX_SQL} AS thinkingIndex,
+						SUM(type = 'thinking_started') AS started,
+						SUM(type = 'thinking_finished') AS finished,
+						MIN(created_at) AS firstAt, MAX(created_at) AS lastAt
+					FROM event_log
+					WHERE event_id IS NOT NULL
+						AND type IN ('thinking_started', 'thinking_finished')
+						${lifecycle.whereSql}
+					GROUP BY session_id, event_id, thinkingIndex
+					HAVING (started != 1 OR finished != 1) ${lifecycle.havingSql}
+					ORDER BY lastAt DESC
+					LIMIT ?
+				`, [...lifecycle.params, limit]).map((row) => ({
+                    kind: "thinking_lifecycle",
+                    piboSessionId: row.sessionId,
+                    eventId: row.eventId,
+                    thinkingIndex: row.thinkingIndex,
+                    firstAt: row.firstAt,
+                    lastAt: row.lastAt,
+                    started: row.started,
+                    finished: row.finished,
+                })));
+                findings.push(...queryRows(db, `
+					SELECT session_id AS sessionId, event_id AS eventId,
+						${TOOL_CALL_ID_SQL} AS toolCallId,
+						${TOOL_ORDINAL_SQL} AS toolInvocationOrdinal,
+						SUM(type = 'tool_call') AS called,
+						SUM(type = 'tool_execution_started') AS started,
+						SUM(type = 'tool_execution_finished') AS finished,
+						MIN(created_at) AS firstAt, MAX(created_at) AS lastAt
+					FROM event_log
+					WHERE event_id IS NOT NULL
+						AND ${TOOL_CALL_ID_SQL} IS NOT NULL
+						AND type IN ('tool_call', 'tool_execution_started', 'tool_execution_finished')
+						${lifecycle.whereSql}
+					GROUP BY session_id, event_id, toolCallId, toolInvocationOrdinal
+					HAVING (called != 1 OR started != 1 OR finished != 1) ${lifecycle.havingSql}
+					ORDER BY lastAt DESC
+					LIMIT ?
+				`, [...lifecycle.params, limit]).map((row) => ({
+                    kind: "tool_lifecycle",
+                    piboSessionId: row.sessionId,
+                    eventId: row.eventId,
+                    toolCallId: row.toolCallId,
+                    toolInvocationOrdinal: row.toolInvocationOrdinal,
+                    called: row.called,
+                    firstAt: row.firstAt,
+                    lastAt: row.lastAt,
+                    started: row.started,
+                    finished: row.finished,
+                })));
+                findings.push(...queryRows(db, `
+					SELECT session_id AS sessionId, event_id AS eventId, stream_id AS streamId,
+						created_at AS createdAt,
+						${COLLISION_KEY_SQL} AS idempotencyKey
+					FROM event_log
+					WHERE type = 'pibo.output.identity_collision' ${scope.sql}
+					ORDER BY stream_id DESC
+					LIMIT ?
+				`, [...scope.params, limit]).map((row) => ({
+                    kind: "identity_collision",
+                    piboSessionId: row.sessionId,
+                    ...(row.eventId ? { eventId: row.eventId } : {}),
+                    streamId: row.streamId,
+                    lastAt: row.createdAt,
+                    ...(row.idempotencyKey ? { idempotencyKey: row.idempotencyKey } : {}),
+                })));
+                findings.push(...queryRows(db, `
+					WITH output_keys AS (
+						SELECT session_id, event_id, idempotency_key AS output_key, created_at
+						FROM event_log
+						WHERE idempotency_key LIKE 'pibo.output:%' ${scope.sql}
+						UNION ALL
+						SELECT session_id, event_id, ${COLLISION_KEY_SQL} AS output_key, created_at
+						FROM event_log
+						WHERE type = 'pibo.output.identity_collision'
+							AND ${COLLISION_KEY_SQL} IS NOT NULL ${scope.sql}
+					)
+					SELECT MIN(session_id) AS sessionId, MIN(event_id) AS eventId, output_key AS outputKey,
+						COUNT(*) AS uses, MIN(created_at) AS firstAt, MAX(created_at) AS lastAt
+					FROM output_keys
+					GROUP BY output_key
+					HAVING COUNT(*) > 1
+					ORDER BY lastAt DESC
+					LIMIT ?
+				`, [...scope.params, ...scope.params, limit]).map((row) => ({
+                    kind: "output_key_reuse",
+                    piboSessionId: row.sessionId,
+                    ...(row.eventId ? { eventId: row.eventId } : {}),
+                    idempotencyKey: row.outputKey,
+                    uses: Number(row.uses),
+                    firstAt: row.firstAt,
+                    lastAt: row.lastAt,
+                })));
+                if (tableExists(db, "sessions")) {
+                    const traceStatus = sessionTraceStatusSql(input.piboSessionId, input.since, input.before, false);
+                    findings.push(...queryRows(db, traceStatus.sql, [...traceStatus.params, limit]).map((row) => ({
+                        kind: "session_trace_status",
+                        piboSessionId: row.sessionId,
+                        sessionStatus: row.sessionStatus,
+                        projectedStatus: row.projectedStatus,
+                        openTurns: Number(row.openTurns),
+                        lastAt: row.lastAt,
+                    })));
+                }
+            }
+            db.exec("COMMIT");
+        }
+        catch (error) {
+            if (db.isTransaction)
+                db.exec("ROLLBACK");
+            throw error;
+        }
+        finally {
+            db.close();
+        }
+    }
+    if (input.reliabilityStore.exists) {
+        const db = new DatabaseSync(input.reliabilityStore.path, { readOnly: true });
+        db.exec("BEGIN");
+        try {
+            const jobScope = reliabilityScope(input.piboSessionId, input.since, input.before, "updated_at");
+            const deadScope = reliabilityScope(input.piboSessionId, input.since, input.before, "dead_at");
+            if (tableExists(db, "pibo_jobs")) {
+                pendingOutputJobs = countRows(db, `
+					SELECT COUNT(*) AS count FROM pibo_jobs
+					WHERE queue IN ('output-persistence', 'output-persistence-cli') ${jobScope.sql}
+				`, jobScope.params);
+                findings.push(...queryRows(db, `
+					SELECT job_id AS jobId, queue, attempts, max_attempts AS maxAttempts,
+						${RELIABILITY_SESSION_ID_SQL} AS piboSessionId,
+						${RELIABILITY_EVENT_ID_SQL} AS eventId,
+						last_error AS lastError, json_valid(payload_json) AS payloadValid, updated_at AS updatedAt
+					FROM pibo_jobs
+					WHERE queue IN ('output-persistence', 'output-persistence-cli') ${jobScope.sql}
+					ORDER BY updated_at DESC
+					LIMIT ?
+				`, [...jobScope.params, limit]).map(pendingJobFinding));
+            }
+            if (tableExists(db, "pibo_dead_jobs")) {
+                deadOutputJobs = countRows(db, `
+					SELECT COUNT(*) AS count FROM pibo_dead_jobs
+					WHERE queue IN ('output-persistence', 'output-persistence-cli') ${deadScope.sql}
+				`, deadScope.params);
+                deadIdentityCollisions = countRows(db, `
+					SELECT COUNT(*) AS count FROM pibo_dead_jobs
+					WHERE queue IN ('output-persistence', 'output-persistence-cli')
+						AND last_error LIKE 'Pibo output identity collision for %' ${deadScope.sql}
+				`, deadScope.params);
+                findings.push(...queryRows(db, `
+					SELECT job_id AS jobId, queue, attempts, max_attempts AS maxAttempts,
+						${RELIABILITY_SESSION_ID_SQL} AS piboSessionId,
+						${RELIABILITY_EVENT_ID_SQL} AS eventId,
+						last_error AS lastError, dead_reason AS deadReason, json_valid(payload_json) AS payloadValid, dead_at AS updatedAt
+					FROM pibo_dead_jobs
+					WHERE queue IN ('output-persistence', 'output-persistence-cli') ${deadScope.sql}
+					ORDER BY dead_at DESC
+					LIMIT ?
+				`, [...deadScope.params, limit]).map((row) => deadJobFinding(row, collisionEventKeys)));
+            }
+            db.exec("COMMIT");
+        }
+        catch (error) {
+            if (db.isTransaction)
+                db.exec("ROLLBACK");
+            throw error;
+        }
+        finally {
+            db.close();
+        }
+    }
+    const visibleFindings = input.findingMode === "dead_letters"
+        ? findings.filter((finding) => finding.kind === "dead_output_job")
+        : findings;
+    visibleFindings.sort((left, right) => (right.lastAt ?? "").localeCompare(left.lastAt ?? ""));
+    const returnedFindings = visibleFindings.slice(0, limit);
+    const findingCount = turnLifecycleIssues
+        + thinkingLifecycleIssues
+        + toolLifecycleIssues
+        + identityCollisions
+        + outputKeyReuses
+        + sessionTraceStatusMismatches
+        + pendingOutputJobs
+        + deadOutputJobs;
+    const nextCommands = input.piboSessionId
+        ? [
+            `pibo debug trace ${input.piboSessionId} --check`,
+            `pibo debug events ${input.piboSessionId} --limit 50`,
+            `pibo debug persistence dead-letters --session ${input.piboSessionId}`,
+        ]
+        : [
+            "pibo debug persistence audit --session <pibo-session-id> --json",
+            "pibo debug persistence dead-letters",
+            "pibo debug jobs list --queue output-persistence",
+        ];
+    return {
+        resultType: "debug.integrity.output",
+        readOnly: true,
+        scope: {
+            ...(input.piboSessionId ? { piboSessionId: input.piboSessionId } : {}),
+            ...(input.since ? { since: input.since } : {}),
+            ...(input.before ? { before: input.before } : {}),
+            limit,
+        },
+        stores: {
+            data: { path: input.dataStore.path, exists: input.dataStore.exists },
+            reliability: { path: input.reliabilityStore.path, exists: input.reliabilityStore.exists },
+        },
+        summary: {
+            findingCount,
+            returnedFindings: returnedFindings.length,
+            turnLifecycleIssues,
+            thinkingLifecycleIssues,
+            toolLifecycleIssues,
+            identityCollisions,
+            outputKeyReuses,
+            sessionTraceStatusMismatches,
+            pendingOutputJobs,
+            deadOutputJobs,
+            deadIdentityCollisions,
+        },
+        findings: returnedFindings,
+        nextCommands,
+    };
+}
+export function outputPersistenceDeadLettersFromAudit(audit) {
+    const deadLetters = audit.findings.filter((finding) => finding.kind === "dead_output_job");
+    return {
+        resultType: "debug.persistence.dead-letters",
+        readOnly: true,
+        scope: audit.scope,
+        summary: {
+            deadOutputJobs: audit.summary.deadOutputJobs,
+            returnedDeadLetters: deadLetters.length,
+            identityCollisions: deadLetters.filter((finding) => finding.identityCollision).length,
+            relatedIdentityCollisions: deadLetters.filter((finding) => finding.relatedIdentityCollision).length,
+        },
+        deadLetters,
+        nextCommands: audit.scope.piboSessionId
+            ? [`pibo debug persistence audit --session ${audit.scope.piboSessionId} --json`]
+            : ["pibo debug persistence audit --json"],
+    };
+}
+export function formatOutputPersistenceDeadLetters(result) {
+    const lines = [
+        "pibo debug persistence dead-letters",
+        `readOnly\t${result.readOnly}`,
+        `session\t${result.scope.piboSessionId ?? "all"}`,
+        ...(result.scope.since ? [`since\t${result.scope.since}`] : []),
+        ...(result.scope.before ? [`before\t${result.scope.before}`] : []),
+        `deadOutputJobs\t${result.summary.deadOutputJobs}`,
+        `returnedDeadLetters\t${result.summary.returnedDeadLetters}`,
+        `identityCollisions\t${result.summary.identityCollisions}`,
+        `relatedIdentityCollisions\t${result.summary.relatedIdentityCollisions}`,
+    ];
+    if (result.deadLetters.length) {
+        lines.push("", "job\tsession\tevent\treason\tcollision\trelated\tlastAt");
+        for (const finding of result.deadLetters) {
+            lines.push([
+                finding.jobId ?? "-",
+                finding.piboSessionId ?? "-",
+                finding.eventId ?? "-",
+                finding.deadReason ?? "-",
+                finding.identityCollision ?? false,
+                finding.relatedIdentityCollision ?? false,
+                finding.lastAt ?? "-",
+            ].join("\t"));
+        }
+    }
+    lines.push("", "Next:", ...result.nextCommands.map((command) => `  ${command}`));
+    return lines.join("\n");
+}
+export function formatOutputIntegrityAudit(audit) {
+    const scope = audit.scope.piboSessionId ?? "all";
+    const lines = [
+        `pibo debug integrity output`,
+        `readOnly\t${audit.readOnly}`,
+        `session\t${scope}`,
+        ...(audit.scope.since ? [`since\t${audit.scope.since}`] : []),
+        ...(audit.scope.before ? [`before\t${audit.scope.before}`] : []),
+        `findings\t${audit.summary.findingCount}`,
+        `turnLifecycle\t${audit.summary.turnLifecycleIssues}`,
+        `thinkingLifecycle\t${audit.summary.thinkingLifecycleIssues}`,
+        `toolLifecycle\t${audit.summary.toolLifecycleIssues}`,
+        `identityCollisions\t${audit.summary.identityCollisions}`,
+        `outputKeyReuses\t${audit.summary.outputKeyReuses}`,
+        `sessionTraceStatusMismatches\t${audit.summary.sessionTraceStatusMismatches}`,
+        `pendingOutputJobs\t${audit.summary.pendingOutputJobs}`,
+        `deadOutputJobs\t${audit.summary.deadOutputJobs}`,
+        `deadIdentityCollisions\t${audit.summary.deadIdentityCollisions}`,
+    ];
+    if (audit.findings.length) {
+        lines.push("", "kind\tsession\tevent\tdetail\tlastAt");
+        for (const finding of audit.findings) {
+            lines.push([
+                finding.kind,
+                finding.piboSessionId ?? "-",
+                finding.eventId ?? finding.jobId ?? "-",
+                findingDetail(finding),
+                finding.lastAt ?? "-",
+            ].join("\t"));
+        }
+    }
+    lines.push("", "Next:", ...audit.nextCommands.map((command) => `  ${command}`));
+    return lines.join("\n");
+}
+function eventScope(piboSessionId, since, before) {
+    const clauses = [];
+    const params = [];
+    if (piboSessionId) {
+        clauses.push("session_id = ?");
+        params.push(piboSessionId);
+    }
+    if (since) {
+        clauses.push("created_at >= ?");
+        params.push(since);
+    }
+    if (before) {
+        clauses.push("created_at < ?");
+        params.push(before);
+    }
+    return { sql: clauses.length ? `AND ${clauses.join(" AND ")}` : "", params };
+}
+function lifecycleScope(piboSessionId, since, before) {
+    const whereClauses = [];
+    const havingClauses = [];
+    const params = [];
+    if (piboSessionId) {
+        whereClauses.push("session_id = ?");
+        params.push(piboSessionId);
+    }
+    if (since) {
+        havingClauses.push("MAX(created_at) >= ?");
+        params.push(since);
+    }
+    if (before) {
+        havingClauses.push("MAX(created_at) < ?");
+        params.push(before);
+    }
+    return {
+        whereSql: whereClauses.length ? `AND ${whereClauses.join(" AND ")}` : "",
+        havingSql: havingClauses.length ? `AND ${havingClauses.join(" AND ")}` : "",
+        params,
+    };
+}
+function reliabilityScope(piboSessionId, since, before, timeColumn) {
+    const clauses = [];
+    const params = [];
+    if (piboSessionId) {
+        clauses.push(`${RELIABILITY_SESSION_ID_SQL} = ?`);
+        params.push(piboSessionId);
+    }
+    if (since) {
+        clauses.push(`${timeColumn} >= ?`);
+        params.push(since);
+    }
+    if (before) {
+        clauses.push(`${timeColumn} < ?`);
+        params.push(before);
+    }
+    return { sql: clauses.length ? `AND ${clauses.join(" AND ")}` : "", params };
+}
+function sessionTraceStatusSql(piboSessionId, since, before, countOnly) {
+    const clauses = [];
+    const params = [];
+    if (piboSessionId) {
+        clauses.push("latest.session_id = ?");
+        params.push(piboSessionId);
+    }
+    if (since) {
+        clauses.push("latest.created_at >= ?");
+        params.push(since);
+    }
+    if (before) {
+        clauses.push("latest.created_at < ?");
+        params.push(before);
+    }
+    const scopeSql = clauses.length ? `AND ${clauses.join(" AND ")}` : "";
+    const ctes = `
+		WITH ranked_status_events AS (
+			SELECT session_id, type, created_at,
+				ROW_NUMBER() OVER (PARTITION BY session_id ORDER BY stream_id DESC) AS rank
+			FROM event_log
+			WHERE session_id IS NOT NULL
+				AND type IN ('message_started', 'message_finished', 'session_error')
+		), latest AS (
+			SELECT session_id, type, created_at
+			FROM ranked_status_events
+			WHERE rank = 1
+		), mismatches AS (
+			SELECT sessions.id AS sessionId, sessions.status AS sessionStatus,
+				CASE latest.type
+					WHEN 'session_error' THEN 'error'
+					WHEN 'message_started' THEN 'running'
+					ELSE 'idle'
+				END AS projectedStatus,
+				CASE WHEN latest.type = 'message_started' THEN 1 ELSE 0 END AS openTurns,
+				latest.created_at AS lastAt
+			FROM sessions
+			JOIN latest ON latest.session_id = sessions.id
+			WHERE CASE WHEN sessions.status IN ('running', 'error') THEN sessions.status ELSE 'idle' END
+				!= CASE latest.type
+					WHEN 'session_error' THEN 'error'
+					WHEN 'message_started' THEN 'running'
+					ELSE 'idle'
+				END
+				${scopeSql}
+		)
+	`;
+    return {
+        sql: countOnly
+            ? `${ctes} SELECT COUNT(*) AS count FROM mismatches`
+            : `${ctes} SELECT * FROM mismatches ORDER BY lastAt DESC LIMIT ?`,
+        params,
+    };
+}
+function queryRows(db, sql, params) {
+    return db.prepare(sql).all(...params);
+}
+function countRows(db, sql, params) {
+    const row = db.prepare(sql).get(...params);
+    return Number(row?.count ?? 0);
+}
+function tableExists(db, table) {
+    return Boolean(db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(table));
+}
+function pendingJobFinding(row) {
+    return {
+        kind: "pending_output_job",
+        ...(row.piboSessionId ? { piboSessionId: row.piboSessionId } : {}),
+        ...(row.eventId ? { eventId: row.eventId } : {}),
+        jobId: row.jobId,
+        queue: row.queue,
+        attempts: row.attempts,
+        maxAttempts: row.maxAttempts,
+        payloadValid: row.payloadValid === 1,
+        lastAt: row.updatedAt,
+    };
+}
+function deadJobFinding(row, collisionEventKeys) {
+    return {
+        kind: "dead_output_job",
+        ...(row.piboSessionId ? { piboSessionId: row.piboSessionId } : {}),
+        ...(row.eventId ? { eventId: row.eventId } : {}),
+        jobId: row.jobId,
+        queue: row.queue,
+        attempts: row.attempts,
+        maxAttempts: row.maxAttempts,
+        ...(row.deadReason ? { deadReason: row.deadReason } : {}),
+        identityCollision: row.lastError?.startsWith("Pibo output identity collision for ") ?? false,
+        relatedIdentityCollision: Boolean(row.piboSessionId && row.eventId && collisionEventKeys.has(`${row.piboSessionId}\0${row.eventId}`)),
+        payloadValid: row.payloadValid === 1,
+        lastAt: row.updatedAt,
+    };
+}
+function findingDetail(finding) {
+    if (finding.kind === "turn_lifecycle")
+        return `started=${finding.started ?? 0},assistant=${finding.assistantMessages ?? 0},messageFinished=${finding.messageFinished ?? 0},sessionErrors=${finding.sessionErrors ?? 0}`;
+    if (finding.kind === "thinking_lifecycle")
+        return `thinking=${finding.thinkingIndex ?? 0},started=${finding.started ?? 0},finished=${finding.finished ?? 0}`;
+    if (finding.kind === "tool_lifecycle")
+        return `tool=${finding.toolCallId ?? "-"},ordinal=${finding.toolInvocationOrdinal ?? 0},called=${finding.called ?? 0},started=${finding.started ?? 0},finished=${finding.finished ?? 0}`;
+    if (finding.kind === "identity_collision")
+        return finding.idempotencyKey ?? `stream=${finding.streamId ?? "-"}`;
+    if (finding.kind === "output_key_reuse")
+        return `uses=${finding.uses ?? 0},key=${finding.idempotencyKey ?? "-"}`;
+    if (finding.kind === "session_trace_status")
+        return `session=${finding.sessionStatus ?? "-"},projected=${finding.projectedStatus ?? "-"},openTurns=${finding.openTurns ?? 0}`;
+    if (finding.kind === "pending_output_job")
+        return `payloadValid=${finding.payloadValid ?? false},attempts=${finding.attempts ?? 0}/${finding.maxAttempts ?? 0}`;
+    return `reason=${finding.deadReason ?? "-"},collision=${finding.identityCollision ?? false},related=${finding.relatedIdentityCollision ?? false},payloadValid=${finding.payloadValid ?? false},attempts=${finding.attempts ?? 0}/${finding.maxAttempts ?? 0}`;
+}