@overdeck/desktop 0.49.2 → 0.50.1

package/server/reconciler-ComAOr_F.js

@@ -0,0 +1,657 @@
+import { Qr as FsError, li as init_errors } from "./config-yaml-OoH-ZpTb.js";
+import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-BbSWNOpH.js";
+import { o as getPricingSync, s as init_cost, t as calculateCostSync } from "./cost-CxXv7ei-.js";
+import { i as CostWriter, o as lookupSkipVerdict, s as recordSkipVerdict, t as CostDoorLive } from "./cost-DR57uJFP.js";
+import { A as init_conversations, st as findConversationForCostSessionSync } from "./conversations-JyrMSeOh.js";
+import { Effect } from "effect";
+import { closeSync, existsSync, fstatSync, openSync, readFileSync, readSync, readdirSync, statSync } from "fs";
+import { basename, join } from "path";
+import { homedir } from "os";
+//#region ../../lib/costs/attribution.ts
+init_errors();
+init_cost();
+init_conversations();
+init_infra();
+const NO_ISSUE_BUCKETS = {
+	conversations: "CONVERSATIONS",
+	flywheel: "FLYWHEEL",
+	unattributed: "UNATTRIBUTED"
+};
+function classifySessionBucket(input, lookup) {
+	const conversation = lookup(input);
+	if (!conversation) return NO_ISSUE_BUCKETS.unattributed;
+	if (conversation.name === "flywheel-orchestrator") return NO_ISSUE_BUCKETS.flywheel;
+	return NO_ISSUE_BUCKETS.conversations;
+}
+function reclassifyUnknownCostEventsSync() {
+	const db = getOverdeckDatabaseSync();
+	const rows = db.prepare(`SELECT DISTINCT session_id AS sessionId, agent_id AS agentId
+     FROM cost_events
+     WHERE issue_id = 'UNKNOWN'`).all();
+	let updated = 0;
+	const update = db.prepare(`UPDATE cost_events
+     SET issue_id = ?
+     WHERE issue_id = 'UNKNOWN'
+       AND session_id IS ?
+       AND agent_id IS ?`);
+	for (const row of rows) {
+		const bucket = classifySessionBucket(row, findConversationForCostSessionSync);
+		const result = update.run(bucket, row.sessionId, row.agentId);
+		updated += result.changes;
+	}
+	return { updated };
+}
+//#endregion
+//#region ../../lib/costs/reconciler.ts
+/**
+* Cost Reconciler — Periodic catch-up sweep for cost tracking
+*
+* The live recording hook (heartbeat-hook → record-cost-event.js) captures costs
+* in real time, but can miss events due to hook failures, process crashes, or
+* system reboots. The reconciler ensures completeness by periodically sweeping
+* ALL Claude transcript files and importing any events not yet in SQLite.
+*
+* v2 Architecture: Scans ~/.claude/projects/ directly instead of going through
+* agent state.json files. This catches everything:
+* - Work agent sessions (from worktree workspaces)
+* - Planning agent sessions (from main project dirs)
+* - Specialist sessions (review, test, merge)
+* - Interactive/manual Claude sessions
+*
+* Key properties:
+* - Idempotent: dedup on request_id — safe to run any number of times
+* - Incremental: tracks byte offset per session — only reads new bytes
+* - Non-destructive: never deletes from SQLite, append-only
+* - Catches everything: scans all transcript files regardless of source
+*/
+init_conversations();
+/**
+* Map a pi-reported provider string to the AIProvider union used by the pricing
+* layer. zai/kimi/minimax/mimo and anything unknown collapse to 'custom' (which
+* is how these providers are keyed in DEFAULT_PRICING).
+*/
+function piProviderToAiProvider(provider) {
+	if (provider === "anthropic") return "anthropic";
+	if (provider === "openai") return "openai";
+	if (provider === "google") return "google";
+	return "custom";
+}
+function getAgentsDir() {
+	return join(process.env.HOME || homedir(), ".overdeck", "agents");
+}
+function getClaudeProjectsDir() {
+	return join(process.env.HOME || homedir(), ".claude", "projects");
+}
+/**
+* Extract session UUID from a transcript filename.
+* e.g., "678c8d8d-cefe-45ca-bebc-bafe602aff93.jsonl" → "678c8d8d-cefe-45ca-bebc-bafe602aff93"
+*/
+function extractSessionId(filename) {
+	return basename(filename, ".jsonl");
+}
+function resolveUnmappedSessionIssueId(input, lookup = findConversationForCostSessionSync) {
+	return classifySessionBucket(input, lookup);
+}
+/**
+* Decode a Claude projects directory name back to the original cwd path.
+* e.g., "-home-eltmon-Projects-krux-workspaces-feature-krux-4" → "/home/eltmon/Projects/krux/workspaces/feature-krux-4"
+*/
+function decodeClaudeDirName(dirName) {
+	return "/" + dirName.replace(/^-/, "").replace(/-/g, "/");
+}
+/**
+* Build a reverse index: session UUID → agent context.
+* Sources:
+* 1. sessions.json files in agent directories (authoritative — written by heartbeat hook)
+* 2. Agent state.json for issue/workspace context
+*/
+function buildSessionIndex() {
+	const index = /* @__PURE__ */ new Map();
+	const agentsDir = getAgentsDir();
+	if (!existsSync(agentsDir)) return index;
+	let entries;
+	try {
+		entries = readdirSync(agentsDir);
+	} catch {
+		return index;
+	}
+	for (const agentDir of entries) {
+		const agentPath = join(agentsDir, agentDir);
+		const sessionsFile = join(agentPath, "sessions.json");
+		let sessionIds = [];
+		if (existsSync(sessionsFile)) try {
+			sessionIds = JSON.parse(readFileSync(sessionsFile, "utf-8"));
+		} catch {}
+		const stateFile = join(agentPath, "state.json");
+		let issueId = inferIssueId(agentDir);
+		let stateRole;
+		if (existsSync(stateFile)) try {
+			const state = JSON.parse(readFileSync(stateFile, "utf-8"));
+			if (state.issueId) issueId = state.issueId;
+			if (state.role) stateRole = state.role;
+		} catch {}
+		let sessionType = stateRole || "work";
+		const reviewSubRole = agentDir.match(/-review-(security|correctness|performance|requirements)$/i)?.[1]?.toLowerCase();
+		if (reviewSubRole) sessionType = `review.${reviewSubRole}`;
+		else if (agentDir.startsWith("planning-")) sessionType = "planning";
+		else if (agentDir.includes("review")) sessionType = "review";
+		else if (agentDir.includes("test")) sessionType = "test";
+		else if (agentDir.includes("merge")) sessionType = "merge";
+		for (const sid of sessionIds) index.set(sid, {
+			agentId: agentDir,
+			issueId: issueId ?? resolveUnmappedSessionIssueId({
+				sessionId: sid,
+				agentId: agentDir
+			}),
+			sessionType
+		});
+	}
+	return index;
+}
+/**
+* Infer issue ID from a decoded path.
+* Looks for patterns like "feature-min-787", "feature/pan-208", etc.
+*/
+function inferIssueFromPath(decodedPath) {
+	const match = decodedPath.match(/(?:feature[-/])?(pan|min|aud|krux|cli)[-/](\d+)/i);
+	if (match) return `${match[1].toUpperCase()}-${match[2]}`;
+	return null;
+}
+/**
+* Infer issue ID from agent directory name.
+* e.g., 'agent-pan-105' → 'PAN-105', 'planning-min-663' → 'MIN-663'
+*/
+function inferIssueId(agentDir) {
+	const match = agentDir.replace(/^(agent|planning|specialist)-/, "").match(/^(?:.*-)?(pan|min|aud|krux|cli)-(\d+)$/i);
+	if (match) return `${match[1].toUpperCase()}-${match[2]}`;
+	return null;
+}
+function getSessionOffset(_sessionId) {
+	return 0;
+}
+function saveSessionOffset(sessionId, byteOffset, newEvents, agentId, issueId, transcriptPath) {}
+/**
+* Read new bytes from a transcript file starting at the given offset.
+*/
+function readNewBytes(filePath, fromOffset) {
+	let fd;
+	try {
+		fd = openSync(filePath, "r");
+	} catch {
+		return null;
+	}
+	try {
+		const stat = fstatSync(fd);
+		if (stat.size <= fromOffset) return {
+			content: "",
+			newSize: stat.size
+		};
+		const bytesToRead = stat.size - fromOffset;
+		const buffer = Buffer.alloc(bytesToRead);
+		readSync(fd, buffer, 0, bytesToRead, fromOffset);
+		return {
+			content: buffer.toString("utf-8"),
+			newSize: stat.size
+		};
+	} finally {
+		closeSync(fd);
+	}
+}
+/**
+* Parse transcript content and extract cost events.
+* Only processes assistant messages with usage data and a requestId.
+*/
+function extractCostEvents(content, agentId, issueId, sessionType, sessionId) {
+	const events = [];
+	const lines = content.split("\n");
+	for (const line of lines) {
+		if (!line.trim()) continue;
+		try {
+			const entry = JSON.parse(line);
+			if (entry.type !== "assistant" || !entry.message?.usage) continue;
+			const requestId = entry.requestId ?? void 0;
+			const usage = entry.message.usage;
+			const model = entry.message.model || "claude-sonnet-4";
+			const inputTokens = usage.input_tokens || 0;
+			const outputTokens = usage.output_tokens || 0;
+			const cacheReadTokens = usage.cache_read_input_tokens || 0;
+			const cacheWriteTokens = usage.cache_creation_input_tokens || 0;
+			if (inputTokens === 0 && outputTokens === 0 && cacheReadTokens === 0 && cacheWriteTokens === 0) continue;
+			let provider = "anthropic";
+			if (model.includes("gpt")) provider = "openai";
+			else if (model.includes("gemini")) provider = "google";
+			else if (model.includes("kimi")) provider = "custom";
+			else if (model.toLowerCase().startsWith("minimax")) provider = "custom";
+			const pricingModel = model.replace(/^(?:oai|cx|go)@/, "");
+			const pricing = getPricingSync(provider, pricingModel);
+			if (!pricing) continue;
+			const cost = calculateCostSync({
+				inputTokens,
+				outputTokens,
+				cacheReadTokens,
+				cacheWriteTokens,
+				cacheTTL: "5m"
+			}, pricing);
+			const timestamp = entry.timestamp || entry.ts || entry.created_at || (/* @__PURE__ */ new Date()).toISOString();
+			events.push({
+				ts: timestamp,
+				type: "cost",
+				agentId,
+				issueId,
+				sessionType,
+				provider,
+				model,
+				input: inputTokens,
+				output: outputTokens,
+				cacheRead: cacheReadTokens,
+				cacheWrite: cacheWriteTokens,
+				cost,
+				requestId,
+				sessionId
+			});
+		} catch {}
+	}
+	return events;
+}
+/**
+* Parse Pi/oh-my-pi transcript content and extract cost events (PAN-1935).
+*
+* Pi's `message.usage` uses short camelCase keys (`input`, `output`,
+* `cacheRead`, `cacheWrite`) and the real model/provider live on `message`
+* (not inferred from a Claude-style `model` field). Cost is always computed
+* from tokens × pricing because pi reports `cost.total = 0` for non-Anthropic
+* providers. Exported for unit testing.
+*/
+function extractPiCostEvents(content, agentId, issueId, sessionType, sessionId) {
+	const events = [];
+	for (const line of content.split("\n")) {
+		if (!line.trim()) continue;
+		let entry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (entry.type !== "message") continue;
+		const usage = entry.message?.usage;
+		if (!usage) continue;
+		const inputTokens = usage.input ?? 0;
+		const outputTokens = usage.output ?? 0;
+		const cacheReadTokens = usage.cacheRead ?? 0;
+		const cacheWriteTokens = usage.cacheWrite ?? 0;
+		if (inputTokens === 0 && outputTokens === 0 && cacheReadTokens === 0 && cacheWriteTokens === 0) continue;
+		const model = entry.message?.model || "unknown";
+		const provider = piProviderToAiProvider(entry.message?.provider);
+		const pricing = getPricingSync(provider, model.replace(/^(?:oai|cx|go)@/, ""));
+		if (!pricing) continue;
+		const cost = calculateCostSync({
+			inputTokens,
+			outputTokens,
+			cacheReadTokens,
+			cacheWriteTokens,
+			cacheTTL: "5m"
+		}, pricing);
+		const requestId = entry.message?.responseId ?? (entry.id ? `${sessionId}#${entry.id}` : void 0);
+		const timestamp = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+		events.push({
+			ts: timestamp,
+			type: "cost",
+			agentId,
+			issueId,
+			sessionType,
+			provider,
+			model,
+			input: inputTokens,
+			output: outputTokens,
+			cacheRead: cacheReadTokens,
+			cacheWrite: cacheWriteTokens,
+			cost,
+			requestId,
+			sessionId
+		});
+	}
+	return events;
+}
+function findPiTranscriptFiles(agentDir) {
+	let files;
+	try {
+		files = readdirSync(agentDir).filter((f) => f.endsWith(".jsonl"));
+	} catch {
+		return [];
+	}
+	const transcripts = [];
+	for (const f of files) {
+		if (f === "activity.jsonl" || f === "cost-events.jsonl" || f === "pending-events.jsonl") continue;
+		const full = join(agentDir, f);
+		try {
+			const stat = statSync(full);
+			const fd = openSync(full, "r");
+			const buf = Buffer.alloc(128);
+			const bytesRead = readSync(fd, buf, 0, 128, 0);
+			closeSync(fd);
+			const head = buf.toString("utf-8", 0, bytesRead);
+			if (/"type"\s*:\s*"session"/.test(head)) transcripts.push({
+				path: full,
+				mtimeMs: stat.mtimeMs,
+				size: stat.size
+			});
+		} catch {}
+	}
+	return transcripts;
+}
+/**
+* Sweep pi session transcripts under the per-agent dirs (~/.overdeck/agents)
+* and import their cost events through the same Overdeck cost writer the Claude
+* path uses (PAN-1935).
+* Independent of the pi extension hook, so it captures cost even when the
+* extension emits null usage or the wrong model label.
+*/
+async function collectPiCostEvents(opts = {}) {
+	const result = {
+		events: [],
+		verdicts: [],
+		stats: {
+			scanned: 0,
+			cacheSkipped: 0,
+			sessionsWithData: 0
+		},
+		errors: []
+	};
+	const agentsDir = getAgentsDir();
+	if (!existsSync(agentsDir)) return result;
+	let agentDirs;
+	try {
+		agentDirs = readdirSync(agentsDir);
+	} catch {
+		return result;
+	}
+	const candidates = [];
+	for (const agentDirName of agentDirs) {
+		const agentPath = join(agentsDir, agentDirName);
+		let issueId = inferIssueId(agentDirName);
+		let sessionType = "work";
+		const stateFile = join(agentPath, "state.json");
+		if (existsSync(stateFile)) try {
+			const st = JSON.parse(readFileSync(stateFile, "utf-8"));
+			if (st.issueId) issueId = st.issueId;
+			if (st.role) sessionType = st.role;
+		} catch {}
+		if (agentDirName.startsWith("planning-")) sessionType = "planning";
+		candidates.push(...findPiTranscriptFiles(agentPath).map((transcript) => ({
+			...transcript,
+			agentDirName,
+			issueId,
+			sessionType
+		})));
+	}
+	candidates.sort((a, b) => a.path.localeCompare(b.path));
+	const maxEvents = opts.maxEvents ?? Number.POSITIVE_INFINITY;
+	const flush = async () => {
+		if (!opts.onBatch || result.events.length === 0 && result.verdicts.length === 0) return;
+		const batch = {
+			events: result.events,
+			verdicts: result.verdicts
+		};
+		result.events = [];
+		result.verdicts = [];
+		await opts.onBatch(batch);
+	};
+	for (const transcript of candidates) {
+		const transcriptPath = transcript.path;
+		const sessionId = basename(transcriptPath, ".jsonl");
+		const resolvedIssueId = transcript.issueId ?? resolveUnmappedSessionIssueId({
+			sessionId,
+			agentId: transcript.agentDirName
+		});
+		result.stats.scanned++;
+		if (lookupSkipVerdict(transcriptPath, transcript.mtimeMs, transcript.size)) {
+			result.stats.cacheSkipped++;
+			continue;
+		}
+		try {
+			const events = extractPiCostEvents(readFileSync(transcriptPath, "utf-8"), transcript.agentDirName, resolvedIssueId, transcript.sessionType, sessionId);
+			if (events.length === 0) {
+				result.verdicts.push({
+					path: transcriptPath,
+					mtimeMs: transcript.mtimeMs,
+					size: transcript.size,
+					verdict: "no-usage"
+				});
+				await flush();
+				continue;
+			}
+			result.stats.sessionsWithData++;
+			for (const event of events) {
+				result.events.push({
+					event,
+					sourceFile: `reconciler:${transcriptPath}`
+				});
+				if (result.events.length >= maxEvents) await flush();
+			}
+			result.verdicts.push({
+				path: transcriptPath,
+				mtimeMs: transcript.mtimeMs,
+				size: transcript.size,
+				verdict: "imported"
+			});
+			await flush();
+		} catch (err) {
+			result.errors.push({
+				path: transcriptPath,
+				error: err instanceof Error ? err.message : String(err)
+			});
+		}
+	}
+	await flush();
+	return result;
+}
+async function reconcilePiTranscripts() {
+	const collected = await collectPiCostEvents();
+	const result = {
+		sessionsScanned: collected.stats.scanned,
+		cacheSkipped: collected.stats.cacheSkipped,
+		sessionsWithNewData: collected.stats.sessionsWithData,
+		eventsImported: 0,
+		duplicatesSkipped: 0,
+		errors: collected.errors,
+		earliestEventTs: null,
+		latestEventTs: null
+	};
+	for (const { event, sourceFile } of collected.events) {
+		const recorded = await recordCostEventsThroughOverdeck([event], sourceFile);
+		result.eventsImported += recorded.inserted;
+		result.duplicatesSkipped += recorded.duplicates;
+		mergeCoverage(result, recorded);
+	}
+	for (const verdict of collected.verdicts) recordSkipVerdict(verdict.path, verdict.mtimeMs, verdict.size, verdict.verdict);
+	return result;
+}
+function toOverdeckCostEvent(event, sourceFile) {
+	return {
+		ts: new Date(event.ts),
+		issueId: event.issueId ? event.issueId : null,
+		agentId: event.agentId ?? null,
+		sessionId: event.sessionId ?? null,
+		sessionType: event.sessionType ?? null,
+		provider: event.provider ?? null,
+		model: event.model ?? null,
+		input: event.input ?? 0,
+		output: event.output ?? 0,
+		cacheRead: event.cacheRead ?? 0,
+		cacheWrite: event.cacheWrite ?? 0,
+		cost: event.cost ?? 0,
+		requestId: event.requestId ?? null,
+		sourceFile
+	};
+}
+async function recordCostEventsThroughOverdeck(events, sourceFile, opts = {}) {
+	let inserted = 0;
+	let duplicates = 0;
+	let earliestEventTs = null;
+	let latestEventTs = null;
+	for (const event of events) if (await Effect.runPromise(CostWriter.use((writer) => writer.record(toOverdeckCostEvent(event, sourceFile), { dryRun: opts.dryRun })).pipe(Effect.provide(CostDoorLive)))) {
+		inserted++;
+		const iso = new Date(event.ts).toISOString();
+		if (earliestEventTs == null || iso < earliestEventTs) earliestEventTs = iso;
+		if (latestEventTs == null || iso > latestEventTs) latestEventTs = iso;
+	} else duplicates++;
+	return {
+		inserted,
+		duplicates,
+		earliestEventTs,
+		latestEventTs
+	};
+}
+function mergeCoverage(result, coverage) {
+	if (coverage.earliestEventTs != null && (result.earliestEventTs == null || coverage.earliestEventTs < result.earliestEventTs)) result.earliestEventTs = coverage.earliestEventTs;
+	if (coverage.latestEventTs != null && (result.latestEventTs == null || coverage.latestEventTs > result.latestEventTs)) result.latestEventTs = coverage.latestEventTs;
+}
+async function reconcilePromise(opts = {}) {
+	const result = {
+		sessionsScanned: 0,
+		cacheSkipped: 0,
+		sessionsWithNewData: 0,
+		eventsImported: 0,
+		duplicatesSkipped: 0,
+		errors: [],
+		earliestEventTs: null,
+		latestEventTs: null
+	};
+	const claudeProjectsDir = getClaudeProjectsDir();
+	if (!existsSync(claudeProjectsDir)) return result;
+	const sessionIndex = buildSessionIndex();
+	let projectDirs;
+	try {
+		projectDirs = readdirSync(claudeProjectsDir);
+	} catch {
+		return result;
+	}
+	for (const dirName of projectDirs) {
+		const projectDir = join(claudeProjectsDir, dirName);
+		try {
+			fstatSync(openSync(projectDir, "r"));
+		} catch {}
+		const pathIssueId = inferIssueFromPath(decodeClaudeDirName(dirName));
+		let files;
+		try {
+			files = readdirSync(projectDir).filter((f) => f.endsWith(".jsonl"));
+		} catch {
+			continue;
+		}
+		for (const file of files) {
+			const sessionId = extractSessionId(file);
+			const transcriptPath = join(projectDir, file);
+			result.sessionsScanned++;
+			try {
+				const transcriptStat = statSync(transcriptPath);
+				if (lookupSkipVerdict(transcriptPath, transcriptStat.mtimeMs, transcriptStat.size)) {
+					result.cacheSkipped++;
+					continue;
+				}
+				const mapping = sessionIndex.get(sessionId);
+				const agentId = mapping?.agentId || "unattributed";
+				const issueId = mapping?.issueId || pathIssueId || resolveUnmappedSessionIssueId({
+					sessionId,
+					agentId
+				});
+				const sessionType = mapping?.sessionType || "implementation";
+				const lastOffset = getSessionOffset(sessionId);
+				const readResult = readNewBytes(transcriptPath, lastOffset);
+				if (!readResult || !readResult.content) {
+					if (!opts.dryRun && readResult && readResult.newSize > lastOffset) saveSessionOffset(sessionId, readResult.newSize, 0, agentId, issueId, transcriptPath);
+					if (!opts.dryRun) recordSkipVerdict(transcriptPath, transcriptStat.mtimeMs, transcriptStat.size, "no-usage");
+					continue;
+				}
+				const events = extractCostEvents(readResult.content, agentId, issueId, sessionType, sessionId);
+				if (events.length === 0) {
+					if (!opts.dryRun) saveSessionOffset(sessionId, readResult.newSize, 0, agentId, issueId, transcriptPath);
+					continue;
+				}
+				result.sessionsWithNewData++;
+				const { inserted, duplicates, earliestEventTs, latestEventTs } = await recordCostEventsThroughOverdeck(events, `reconciler:${transcriptPath}`, { dryRun: opts.dryRun });
+				result.eventsImported += inserted;
+				result.duplicatesSkipped += duplicates;
+				mergeCoverage(result, {
+					earliestEventTs,
+					latestEventTs
+				});
+				if (!opts.dryRun) {
+					saveSessionOffset(sessionId, readResult.newSize, inserted, agentId, issueId, transcriptPath);
+					recordSkipVerdict(transcriptPath, transcriptStat.mtimeMs, transcriptStat.size, "imported");
+				}
+			} catch (err) {
+				result.errors.push({
+					path: transcriptPath,
+					error: err instanceof Error ? err.message : String(err)
+				});
+			}
+		}
+		const subagentsDir = join(projectDir, "subagents");
+		if (existsSync(subagentsDir)) try {
+			const subFiles = readdirSync(subagentsDir).filter((f) => f.endsWith(".jsonl"));
+			for (const file of subFiles) {
+				const sessionId = `sub-${extractSessionId(file)}`;
+				const transcriptPath = join(subagentsDir, file);
+				result.sessionsScanned++;
+				try {
+					const mapping = sessionIndex.get(sessionId);
+					const agentId = mapping?.agentId || "unattributed-subagent";
+					const issueId = mapping?.issueId || pathIssueId || resolveUnmappedSessionIssueId({
+						sessionId,
+						agentId
+					});
+					const sessionType = mapping?.sessionType || "implementation";
+					const readResult = readNewBytes(transcriptPath, getSessionOffset(sessionId));
+					if (!readResult || !readResult.content) continue;
+					const events = extractCostEvents(readResult.content, agentId, issueId, sessionType, sessionId);
+					if (events.length === 0) {
+						if (!opts.dryRun) saveSessionOffset(sessionId, readResult.newSize, 0, agentId, issueId, transcriptPath);
+						continue;
+					}
+					result.sessionsWithNewData++;
+					const { inserted, duplicates, earliestEventTs, latestEventTs } = await recordCostEventsThroughOverdeck(events, `reconciler:${transcriptPath}`, { dryRun: opts.dryRun });
+					result.eventsImported += inserted;
+					result.duplicatesSkipped += duplicates;
+					mergeCoverage(result, {
+						earliestEventTs,
+						latestEventTs
+					});
+					if (!opts.dryRun) saveSessionOffset(sessionId, readResult.newSize, inserted, agentId, issueId, transcriptPath);
+				} catch (err) {
+					result.errors.push({
+						path: transcriptPath,
+						error: err instanceof Error ? err.message : String(err)
+					});
+				}
+			}
+		} catch {}
+	}
+	if (opts.includePi ?? true) {
+		const piResult = await reconcilePiTranscripts();
+		result.sessionsScanned += piResult.sessionsScanned;
+		result.cacheSkipped += piResult.cacheSkipped;
+		result.sessionsWithNewData += piResult.sessionsWithNewData;
+		result.eventsImported += piResult.eventsImported;
+		result.duplicatesSkipped += piResult.duplicatesSkipped;
+		result.errors.push(...piResult.errors);
+		mergeCoverage(result, piResult);
+	}
+	return result;
+}
+/**
+* Effect variant of reconcile. Per-file errors are still surfaced via
+* `result.errors`; only catastrophic failures (e.g. SQLite open failure)
+* surface on the Effect error channel.
+*/
+const reconcile = (opts = {}) => Effect.tryPromise({
+	try: () => reconcilePromise(opts),
+	catch: (cause) => new FsError({
+		path: "<reconciler>",
+		operation: "reconcile",
+		cause
+	})
+});
+//#endregion
+export { reclassifyUnknownCostEventsSync as i, reconcile as n, recordCostEventsThroughOverdeck as r, collectPiCostEvents as t };
+
+//# sourceMappingURL=reconciler-ComAOr_F.js.map

package/server/{reconstruct-cache-mxIYCnqs.js → reconstruct-cache-DbjgwKRi.js}

@@ -1,8 +1,8 @@
-import { $ as readIssueRecord, Y as init_record, fn as init_projects, rt as resolveProjectForIssue, vn as listProjectsSync } from "./config-yaml-D9nfpEx1.js";
-import { c as init_agents, i as backfillAgentsSync, u as listAllAgentsSync } from "./agents-jXgqpHca.js";
-import { q as init_agents$1, vn as listRunningAgents } from "./agent-state-BJhGIJZe.js";
-import { a as gatherProjectLensSignals, o as gatherProjectLensSignalsForProjects, s as init_pipeline_membership_gather } from "./pipeline-membership-gather-BK4dzh0X.js";
-import { n as init_pipeline_membership, r as resolvePipelineMembership } from "./pipeline-membership-PGX3Pe8V.js";
+import { $ as readIssueRecord, Y as init_record, fn as init_projects, rt as resolveProjectForIssue, vn as listProjectsSync } from "./config-yaml-OoH-ZpTb.js";
+import { c as init_agents, i as backfillAgentsSync, u as listAllAgentsSync } from "./agents-DMs1aLRU.js";
+import { q as init_agents$1, vn as listRunningAgents } from "./agent-state-BnyNoDWQ.js";
+import { a as gatherProjectLensSignals, o as gatherProjectLensSignalsForProjects, s as init_pipeline_membership_gather } from "./pipeline-membership-gather-UN7kHpCD.js";
+import { n as init_pipeline_membership, r as resolvePipelineMembership } from "./pipeline-membership-BV4hdkHm.js";
 import { Effect } from "effect";
 //#region ../../lib/reconstruct/enumerate-in-flight.ts
 init_projects();
@@ -139,7 +139,7 @@ async function loadInFlightIssueIds(projects) {
 	return enumerateInFlightIssuesFromSources(projects);
 }
 async function fetchPrState(issueId) {
-	const { fetchIssuePullRequest } = await import("./pull-requests-jVGcVq5G.js");
+	const { fetchIssuePullRequest } = await import("./pull-requests-DV_rJ-1u.js");
 	const result = await fetchIssuePullRequest(issueId);
 	if (!result.pr) return {
 		hasPr: false,
@@ -263,4 +263,4 @@ function reconstructCacheAuto(opts) {
 //#endregion
 export { reconstructCache, reconstructCacheAuto };
 
-//# sourceMappingURL=reconstruct-cache-mxIYCnqs.js.map
+//# sourceMappingURL=reconstruct-cache-DbjgwKRi.js.map

package/server/{record-Ug18Cp4V.js → record-C4JJCL2f.js}

@@ -1,3 +1,3 @@
-import { $ as readIssueRecord, B as clearIssueOwner, F as appendSessionEntry, G as getIssueRecordPath, H as ensureIssueRecord, I as appendSessionEntrySync, J as getProjectConfigFromWorkspacePath, K as getIssueRecordPathForWorkspace, L as batchReadIssueRecords, M as RECORD_SCHEMA_VERSION, N as appendFeedbackEntry, P as appendFeedbackEntrySync, Q as queueIssueRecordCommit, R as buildOwnUri, U as ensureIssueRecordSync, V as clearRecordFeedbackSync, W as getIssueRecordBasePath, X as markRecordPipelineClosedOutSync, Y as init_record, Z as markRecordPipelineResidueClosedOutSync, _t as writeRecordTieredExecutionOverride, at as writeAgentHarnessModelSync, bt as writeStatusOverrideSync, ct as writeIssueRecordForWorkspaceSync, dt as writeRecordDecisionsSync, et as readIssueRecordForWorkspaceSync, ft as writeRecordHazards, gt as writeRecordScopeDriftSync, ht as writeRecordResumePointSync, it as writeAgentHarnessModel, j as RECORD_DIRNAME, lt as writeIssueRecordSync, mt as writeRecordResumePoint, nt as readRecordContinueViewSync, ot as writeCloseOutDodGate, pt as writeRecordHazardsSync, q as getIssueWorkspacePath, rt as resolveProjectForIssue, st as writeCloseOutDodGateSync, tt as readIssueRecordSync, ut as writeRecordDecisions, vt as writeRecordTieredExecutionOverrideSync, xt as writeStatusOverridesSync, yt as writeStatusOverride, z as claimIssueOwner } from "./config-yaml-D9nfpEx1.js";
+import { $ as readIssueRecord, B as clearIssueOwner, F as appendSessionEntry, G as getIssueRecordPath, H as ensureIssueRecord, I as appendSessionEntrySync, J as getProjectConfigFromWorkspacePath, K as getIssueRecordPathForWorkspace, L as batchReadIssueRecords, M as RECORD_SCHEMA_VERSION, N as appendFeedbackEntry, P as appendFeedbackEntrySync, Q as queueIssueRecordCommit, R as buildOwnUri, U as ensureIssueRecordSync, V as clearRecordFeedbackSync, W as getIssueRecordBasePath, X as markRecordPipelineClosedOutSync, Y as init_record, Z as markRecordPipelineResidueClosedOutSync, _t as writeRecordTieredExecutionOverride, at as writeAgentHarnessModelSync, bt as writeStatusOverrideSync, ct as writeIssueRecordForWorkspaceSync, dt as writeRecordDecisionsSync, et as readIssueRecordForWorkspaceSync, ft as writeRecordHazards, gt as writeRecordScopeDriftSync, ht as writeRecordResumePointSync, it as writeAgentHarnessModel, j as RECORD_DIRNAME, lt as writeIssueRecordSync, mt as writeRecordResumePoint, nt as readRecordContinueViewSync, ot as writeCloseOutDodGate, pt as writeRecordHazardsSync, q as getIssueWorkspacePath, rt as resolveProjectForIssue, st as writeCloseOutDodGateSync, tt as readIssueRecordSync, ut as writeRecordDecisions, vt as writeRecordTieredExecutionOverrideSync, xt as writeStatusOverridesSync, yt as writeStatusOverride, z as claimIssueOwner } from "./config-yaml-OoH-ZpTb.js";
 init_record();
 export { RECORD_DIRNAME, RECORD_SCHEMA_VERSION, appendFeedbackEntry, appendFeedbackEntrySync, appendSessionEntry, appendSessionEntrySync, batchReadIssueRecords, buildOwnUri, claimIssueOwner, clearIssueOwner, clearRecordFeedbackSync, ensureIssueRecord, ensureIssueRecordSync, getIssueRecordBasePath, getIssueRecordPath, getIssueRecordPathForWorkspace, getIssueWorkspacePath, getProjectConfigFromWorkspacePath, markRecordPipelineClosedOutSync, markRecordPipelineResidueClosedOutSync, queueIssueRecordCommit, readIssueRecord, readIssueRecordForWorkspaceSync, readIssueRecordSync, readRecordContinueViewSync, resolveProjectForIssue, writeAgentHarnessModel, writeAgentHarnessModelSync, writeCloseOutDodGate, writeCloseOutDodGateSync, writeIssueRecordForWorkspaceSync, writeIssueRecordSync, writeRecordDecisions, writeRecordDecisionsSync, writeRecordHazards, writeRecordHazardsSync, writeRecordResumePoint, writeRecordResumePointSync, writeRecordScopeDriftSync, writeRecordTieredExecutionOverride, writeRecordTieredExecutionOverrideSync, writeStatusOverride, writeStatusOverrideSync, writeStatusOverridesSync };