@overdeck/desktop 0.49.2 → 0.50.0

package/server/cost-3FyqKK56.js

@@ -0,0 +1,838 @@
+import { Ri as getOverdeckHome, zi as init_paths } from "./config-yaml-D60AnTIu.js";
+import { D as sql, E as like, S as gte, _ as integer, a as EventBus, b as and, d as getOverdeckDatabaseSync, f as init_infra, g as real, h as text, i as DbLive, m as sqliteTable, n as CostArchiveLive, o as EventBusLive, p as init_sqlite_core, r as Db, t as CostArchive, v as init_drizzle_orm, x as eq, y as desc } from "./infra-CJRi_5Wu.js";
+import { n as init_issues, t as IssueId } from "./issues-RGHQUKhB.js";
+import { a as getAllBudgetsSync, i as deleteBudgetSync, n as checkBudgetSync, r as createBudgetSync, s as init_cost } from "./cost-DTuIRE4y.js";
+import { A as parseOhmypiSessionCostResultSync, k as init_ohmypi_parser } from "./control-settings-Db0uXgVM.js";
+import { _ as init_tier_metrics, h as deriveTieredAgentCostRole } from "./cost-sync-DfmvLT9L.js";
+import { i as parseCodexSessionSync, n as init_codex_parser, r as parseCodexSessionCostEventsSync } from "./behavior-DCg8CIWC.js";
+import { join } from "node:path";
+import { Context, Effect, Layer, Schema } from "effect";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+//#region ../../lib/costs/skip-cache.ts
+init_paths();
+init_drizzle_orm();
+init_sqlite_core();
+init_issues();
+init_cost();
+init_ohmypi_parser();
+init_tier_metrics();
+init_infra();
+function lookupSkipVerdict(path, mtimeMs, size) {
+	return getOverdeckDatabaseSync().prepare(`
+      SELECT verdict
+      FROM cost_reconcile_file_state
+      WHERE path = ? AND mtime_ms = ? AND size = ?
+    `).get(path, mtimeMs, size)?.verdict ?? null;
+}
+function recordSkipVerdict(path, mtimeMs, size, verdict) {
+	getOverdeckDatabaseSync().prepare(`
+      INSERT INTO cost_reconcile_file_state (path, mtime_ms, size, verdict)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(path) DO UPDATE SET
+        mtime_ms = excluded.mtime_ms,
+        size = excluded.size,
+        verdict = excluded.verdict
+    `).run(path, mtimeMs, size, verdict);
+}
+//#endregion
+//#region ../../lib/costs/codex-collector.ts
+init_codex_parser();
+function walkJsonl$1(dir) {
+	if (!existsSync(dir)) return [];
+	return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+		const full = join(dir, entry.name);
+		return entry.isDirectory() ? walkJsonl$1(full) : entry.name.endsWith(".jsonl") ? [full] : [];
+	});
+}
+function issueIdFromAgentName$1(name) {
+	const match = name.match(/(?:agent|planning)-((?:[a-z]+-)?\d+)/i);
+	return match?.[1] ? match[1].toUpperCase() : null;
+}
+function inferIssueFromPath$1(path) {
+	const match = path?.match(/(?:feature[-/]|workspaces\/feature-)([a-z]+-\d+)/i);
+	return match?.[1] ? match[1].toUpperCase() : null;
+}
+async function collectCodexCostEvents(opts = {}) {
+	const agentsDir = join(getOverdeckHome(), "agents");
+	const roots = (existsSync(agentsDir) ? readdirSync(agentsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name) : []).map((agentName) => ({
+		root: join(agentsDir, agentName, "codex-home", "sessions"),
+		agentName,
+		issueId: issueIdFromAgentName$1(agentName),
+		inferIssueFromCwd: false
+	}));
+	for (const root of opts.extraRoots ?? []) roots.push({
+		root,
+		agentName: "codex-global",
+		issueId: null,
+		inferIssueFromCwd: true
+	});
+	for (const extra of opts.extraRootSpecs ?? []) if (extra.kind === "codex-global") roots.push({
+		root: extra.root,
+		agentName: "codex-global",
+		issueId: null,
+		inferIssueFromCwd: true
+	});
+	let events = [];
+	let verdicts = [];
+	const skipped = [];
+	const errors = [];
+	let scanned = 0;
+	let cacheSkipped = 0;
+	const candidates = roots.flatMap((root) => walkJsonl$1(root.root).map((file) => ({
+		file,
+		root
+	}))).sort((a, b) => a.file.localeCompare(b.file));
+	const maxEvents = opts.maxEvents ?? Number.POSITIVE_INFINITY;
+	const flush = async () => {
+		if (!opts.onBatch || events.length === 0 && verdicts.length === 0) return;
+		const batch = {
+			events,
+			verdicts
+		};
+		events = [];
+		verdicts = [];
+		await opts.onBatch(batch);
+	};
+	for (const { file, root } of candidates) {
+		scanned++;
+		const stat = statSync(file);
+		if (lookupSkipVerdict(file, stat.mtimeMs, stat.size)) {
+			cacheSkipped++;
+			continue;
+		}
+		let parsed;
+		try {
+			parsed = parseCodexSessionCostEventsSync(file);
+		} catch (cause) {
+			errors.push(`${file}: ${cause instanceof Error ? cause.message : String(cause)}`);
+			continue;
+		}
+		if (parsed.length === 0) {
+			skipped.push({
+				file,
+				reason: "no-usage"
+			});
+			verdicts.push({
+				path: file,
+				mtimeMs: stat.mtimeMs,
+				size: stat.size,
+				verdict: "no-usage"
+			});
+			await flush();
+			continue;
+		}
+		const unknown = parsed.some((event) => event.model === "unknown");
+		if (unknown) skipped.push({
+			file,
+			reason: "unknown-model"
+		});
+		const session = root.inferIssueFromCwd ? parseCodexSessionSync(file) : null;
+		const issueId = root.inferIssueFromCwd ? inferIssueFromPath$1(session?.cwd) ?? "UNKNOWN" : root.issueId;
+		for (const usage of parsed) {
+			events.push({
+				ts: new Date(usage.timestamp),
+				issueId,
+				agentId: root.agentName,
+				sessionId: usage.sessionId,
+				sessionType: "codex",
+				provider: usage.provider,
+				model: usage.model,
+				input: usage.input,
+				output: usage.output,
+				cacheRead: usage.cacheRead,
+				cacheWrite: usage.cacheWrite,
+				cost: usage.cost,
+				requestId: usage.requestId,
+				sourceFile: file
+			});
+			if (events.length >= maxEvents) await flush();
+		}
+		verdicts.push({
+			path: file,
+			mtimeMs: stat.mtimeMs,
+			size: stat.size,
+			verdict: unknown ? "unknown-model" : "imported"
+		});
+		await flush();
+	}
+	await flush();
+	return {
+		events,
+		verdicts,
+		stats: {
+			scanned,
+			cacheSkipped
+		},
+		skipped,
+		errors
+	};
+}
+//#endregion
+//#region ../../lib/overdeck/cost.ts
+init_infra();
+init_paths();
+function walkJsonl(dir) {
+	if (!existsSync(dir)) return [];
+	const result = [];
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		const full = join(dir, entry.name);
+		if (entry.isDirectory()) result.push(...walkJsonl(full));
+		else if (entry.name.endsWith(".jsonl")) result.push(full);
+	}
+	return result;
+}
+const costEventsTable = sqliteTable("cost_events", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	ts: integer("ts", { mode: "timestamp_ms" }).notNull(),
+	issueId: text("issue_id"),
+	agentId: text("agent_id"),
+	sessionId: text("session_id"),
+	sessionType: text("session_type"),
+	provider: text("provider"),
+	model: text("model"),
+	input: integer("input"),
+	output: integer("output"),
+	cacheRead: integer("cache_read"),
+	cacheWrite: integer("cache_write"),
+	cost: real("cost"),
+	requestId: text("request_id"),
+	sourceFile: text("source_file")
+});
+const Tokens = Schema.Struct({
+	input: Schema.Number,
+	output: Schema.Number,
+	cacheRead: Schema.Number,
+	cacheWrite: Schema.Number
+});
+const CostEvent = Schema.Struct({
+	ts: Schema.Date,
+	issueId: Schema.NullOr(IssueId),
+	agentId: Schema.NullOr(Schema.String),
+	sessionId: Schema.NullOr(Schema.String),
+	sessionType: Schema.NullOr(Schema.String),
+	provider: Schema.NullOr(Schema.String),
+	model: Schema.NullOr(Schema.String),
+	input: Schema.Number,
+	output: Schema.Number,
+	cacheRead: Schema.Number,
+	cacheWrite: Schema.Number,
+	cost: Schema.Number,
+	requestId: Schema.NullOr(Schema.String),
+	sourceFile: Schema.NullOr(Schema.String),
+	warnings: Schema.optional(Schema.Array(Schema.Struct({
+		type: Schema.String,
+		provider: Schema.NullOr(Schema.String),
+		model: Schema.String,
+		reason: Schema.String
+	})))
+});
+const Rollup = Schema.Struct({
+	key: Schema.String,
+	role: Schema.optional(Schema.String),
+	cost: Schema.Number,
+	tokens: Tokens
+});
+const Window = Schema.Literals([
+	"day",
+	"week",
+	"month"
+]);
+const WindowSummary = Schema.Struct({
+	project: Schema.NullOr(Schema.String),
+	window: Window,
+	totalCost: Schema.Number,
+	totalTokens: Schema.Number,
+	entryCount: Schema.Number,
+	byModel: Schema.Record(Schema.String, Schema.Number)
+});
+const IssueCost = Schema.Struct({
+	issueId: IssueId,
+	totalCost: Schema.Number,
+	tokens: Tokens,
+	byModel: Schema.Record(Schema.String, Rollup),
+	byStage: Schema.Record(Schema.String, Schema.Record(Schema.String, Tokens))
+});
+const BudgetSpec = Schema.Struct({
+	name: Schema.String,
+	type: Schema.Literals([
+		"daily",
+		"monthly",
+		"project",
+		"issue",
+		"feature"
+	]),
+	limit: Schema.Number,
+	currency: Schema.String,
+	alertThreshold: Schema.Number
+});
+const Budget = Schema.Struct({
+	...BudgetSpec.fields,
+	id: Schema.String,
+	spent: Schema.Number,
+	enabled: Schema.Boolean
+});
+const BudgetStatus = Schema.Struct({
+	budget: Budget,
+	percentUsed: Schema.Number,
+	remaining: Schema.Number,
+	alert: Schema.Boolean,
+	exceeded: Schema.Boolean
+});
+var CostIngestError = class extends Schema.TaggedErrorClass()("CostIngestError", { reason: Schema.String }) {};
+var BudgetNotFound = class extends Schema.TaggedErrorClass()("BudgetNotFound", { id: Schema.String }) {};
+function mapBudget(b) {
+	return {
+		id: b.id,
+		name: b.name,
+		type: b.type,
+		limit: b.limit,
+		currency: b.currency,
+		alertThreshold: b.alertThreshold,
+		spent: b.spent,
+		enabled: b.enabled
+	};
+}
+function toTokens(r) {
+	return {
+		input: r.input ?? 0,
+		output: r.output ?? 0,
+		cacheRead: r.cacheRead ?? 0,
+		cacheWrite: r.cacheWrite ?? 0
+	};
+}
+function toRollup(key, r, role) {
+	return {
+		key,
+		...role ? { role } : {},
+		cost: r.cost ?? 0,
+		tokens: toTokens(r)
+	};
+}
+function issueIdFromAgentName(agentName) {
+	const match = agentName.match(/(?:^|-)((?:pan|min|aud|krux|cli)-\d+)(?:-|$)/i);
+	return match ? match[1].toUpperCase() : null;
+}
+function inferIssueFromPath(path) {
+	if (!path) return null;
+	const match = path.match(/(?:feature[-/])?(pan|min|aud|krux|cli)[-/](\d+)/i);
+	return match ? `${match[1].toUpperCase()}-${match[2]}` : null;
+}
+function inferIssueFromPiEncodedRootName(name) {
+	return inferIssueFromPath(name.replace(/--+/g, "/"));
+}
+function inferPiProvider(model, provider) {
+	if (provider) return provider;
+	const lower = model.toLowerCase();
+	if (lower.includes("kimi") || lower.startsWith("minimax")) return "custom";
+	if (lower.includes("claude")) return "anthropic";
+	if (lower.includes("gpt")) return "openai";
+	if (lower.includes("gemini")) return "google";
+	return null;
+}
+var CostResolver = class extends Context.Service()("overdeck/CostResolver") {};
+const CostResolverLive = Layer.effect(CostResolver, Effect.gen(function* () {
+	const { q } = yield* Db;
+	const groupBySelect = {
+		cost: sql`SUM(${costEventsTable.cost})`,
+		input: sql`SUM(${costEventsTable.input})`,
+		output: sql`SUM(${costEventsTable.output})`,
+		cacheRead: sql`SUM(${costEventsTable.cacheRead})`,
+		cacheWrite: sql`SUM(${costEventsTable.cacheWrite})`
+	};
+	const summary = (window, project) => Effect.promise(async () => {
+		const days = {
+			day: 1,
+			week: 7,
+			month: 30
+		}[window];
+		const cutoff = /* @__PURE__ */ new Date(Date.now() - days * 864e5);
+		const where = project ? and(gte(costEventsTable.ts, cutoff), like(costEventsTable.issueId, `${project}-%`)) : gte(costEventsTable.ts, cutoff);
+		const [agg] = await q.select({
+			totalCost: sql`COALESCE(SUM(${costEventsTable.cost}), 0)`,
+			totalTokens: sql`COALESCE(SUM(COALESCE(${costEventsTable.input},0) + COALESCE(${costEventsTable.output},0) + COALESCE(${costEventsTable.cacheRead},0) + COALESCE(${costEventsTable.cacheWrite},0)), 0)`,
+			entryCount: sql`COUNT(*)`
+		}).from(costEventsTable).where(where);
+		const modelRows = await q.select({
+			model: costEventsTable.model,
+			cost: sql`COALESCE(SUM(${costEventsTable.cost}), 0)`
+		}).from(costEventsTable).where(where).groupBy(costEventsTable.model);
+		const byModel = {};
+		for (const r of modelRows) byModel[r.model ?? "unknown"] = r.cost ?? 0;
+		return {
+			project: project ?? null,
+			window,
+			totalCost: agg?.totalCost ?? 0,
+			totalTokens: agg?.totalTokens ?? 0,
+			entryCount: agg?.entryCount ?? 0,
+			byModel
+		};
+	});
+	const byIssue = () => Effect.promise(async () => {
+		return (await q.select({
+			key: costEventsTable.issueId,
+			...groupBySelect
+		}).from(costEventsTable).groupBy(costEventsTable.issueId)).map((r) => toRollup(r.key ?? "unattributed", r));
+	});
+	const issueDetail = (id) => Effect.promise(async () => {
+		const modelRows = await q.select({
+			model: costEventsTable.model,
+			...groupBySelect
+		}).from(costEventsTable).where(eq(costEventsTable.issueId, id)).groupBy(costEventsTable.model);
+		const byModel = {};
+		let totalCost = 0;
+		let totalInput = 0, totalOutput = 0, totalCacheRead = 0, totalCacheWrite = 0;
+		for (const r of modelRows) {
+			const key = r.model ?? "unknown";
+			const t = toTokens(r);
+			byModel[key] = {
+				key,
+				cost: r.cost ?? 0,
+				tokens: t
+			};
+			totalCost += r.cost ?? 0;
+			totalInput += t.input;
+			totalOutput += t.output;
+			totalCacheRead += t.cacheRead;
+			totalCacheWrite += t.cacheWrite;
+		}
+		const tokens = {
+			input: totalInput,
+			output: totalOutput,
+			cacheRead: totalCacheRead,
+			cacheWrite: totalCacheWrite
+		};
+		const stageRows = await q.select({
+			stage: costEventsTable.sessionType,
+			model: costEventsTable.model,
+			input: sql`SUM(${costEventsTable.input})`,
+			output: sql`SUM(${costEventsTable.output})`,
+			cacheRead: sql`SUM(${costEventsTable.cacheRead})`,
+			cacheWrite: sql`SUM(${costEventsTable.cacheWrite})`
+		}).from(costEventsTable).where(eq(costEventsTable.issueId, id)).groupBy(costEventsTable.sessionType, costEventsTable.model);
+		const byStage = {};
+		for (const r of stageRows) {
+			const stage = r.stage ?? "unknown";
+			const model = r.model ?? "unknown";
+			if (!byStage[stage]) byStage[stage] = {};
+			byStage[stage][model] = toTokens(r);
+		}
+		return {
+			issueId: id,
+			totalCost,
+			tokens,
+			byModel,
+			byStage
+		};
+	});
+	const byDay = (days, issue) => Effect.promise(async () => {
+		const cutoff = /* @__PURE__ */ new Date(Date.now() - days * 864e5);
+		const dayExpr = sql`DATE(${costEventsTable.ts}, 'unixepoch')`;
+		const where = issue ? and(gte(costEventsTable.ts, cutoff), eq(costEventsTable.issueId, issue)) : gte(costEventsTable.ts, cutoff);
+		return (await q.select({
+			key: dayExpr,
+			...groupBySelect
+		}).from(costEventsTable).where(where).groupBy(dayExpr).orderBy(sql`DATE(${costEventsTable.ts}, 'unixepoch') DESC`)).map((r) => toRollup(r.key ?? "", r));
+	});
+	const byModel = (issue) => Effect.promise(async () => {
+		return (await q.select({
+			key: costEventsTable.model,
+			...groupBySelect
+		}).from(costEventsTable).where(issue ? eq(costEventsTable.issueId, issue) : void 0).groupBy(costEventsTable.model)).map((r) => toRollup(r.key ?? "unknown", r));
+	});
+	const byAgent = (issue) => Effect.promise(async () => {
+		return (await q.select({
+			key: costEventsTable.agentId,
+			...groupBySelect
+		}).from(costEventsTable).where(issue ? eq(costEventsTable.issueId, issue) : void 0).groupBy(costEventsTable.agentId)).map((r) => {
+			const key = r.key ?? "unattributed";
+			return toRollup(key, r, deriveTieredAgentCostRole(key, issue));
+		});
+	});
+	const byBackgroundSource = (hours) => Effect.promise(async () => {
+		const cutoff = /* @__PURE__ */ new Date(Date.now() - hours * 36e5);
+		return (await q.select({
+			key: costEventsTable.sourceFile,
+			...groupBySelect
+		}).from(costEventsTable).where(and(gte(costEventsTable.ts, cutoff), sql`${costEventsTable.sourceFile} IS NOT NULL`)).groupBy(costEventsTable.sourceFile)).map((r) => toRollup(r.key ?? "unknown", r));
+	});
+	const byProject = () => Effect.promise(async () => {
+		const projExpr = sql`UPPER(SUBSTR(${costEventsTable.issueId}, 1, INSTR(${costEventsTable.issueId}, '-') - 1))`;
+		return (await q.select({
+			key: projExpr,
+			...groupBySelect
+		}).from(costEventsTable).where(sql`${costEventsTable.issueId} IS NOT NULL`).groupBy(projExpr)).map((r) => toRollup(r.key ?? "unknown", r));
+	});
+	const recent = (limit, since) => Effect.promise(async () => {
+		return (await q.select().from(costEventsTable).where(since ? gte(costEventsTable.ts, since) : void 0).orderBy(desc(costEventsTable.ts)).limit(limit)).map((r) => ({
+			ts: r.ts,
+			issueId: r.issueId ?? null,
+			agentId: r.agentId ?? null,
+			sessionId: r.sessionId ?? null,
+			sessionType: r.sessionType ?? null,
+			provider: r.provider ?? null,
+			model: r.model ?? null,
+			input: r.input ?? 0,
+			output: r.output ?? 0,
+			cacheRead: r.cacheRead ?? 0,
+			cacheWrite: r.cacheWrite ?? 0,
+			cost: r.cost ?? 0,
+			requestId: r.requestId ?? null,
+			sourceFile: r.sourceFile ?? null
+		}));
+	});
+	const listBudgets = () => Effect.sync(() => getAllBudgetsSync().map(mapBudget));
+	const checkBudget = (id) => Effect.gen(function* () {
+		const result = yield* Effect.sync(() => checkBudgetSync(id));
+		if (!result.budget) return yield* Effect.fail(new BudgetNotFound({ id }));
+		return {
+			budget: mapBudget(result.budget),
+			percentUsed: result.percentUsed,
+			remaining: result.remaining,
+			alert: result.alert,
+			exceeded: result.exceeded
+		};
+	});
+	return CostResolver.of({
+		summary,
+		byIssue,
+		issueDetail,
+		byDay,
+		byModel,
+		byAgent,
+		byBackgroundSource,
+		byProject,
+		recent,
+		listBudgets,
+		checkBudget
+	});
+}));
+var CostWriter = class extends Context.Service()("overdeck/CostWriter") {};
+const CostDoorLive = Layer.effect(CostWriter, Effect.gen(function* () {
+	const { q } = yield* Db;
+	const archive = yield* CostArchive;
+	const bus = yield* EventBus;
+	const checkDuplicate = (e) => Effect.gen(function* () {
+		if (e.requestId == null && e.sourceFile == null) return false;
+		const condition = e.requestId != null ? eq(costEventsTable.requestId, e.requestId) : eq(costEventsTable.sourceFile, e.sourceFile);
+		return (yield* Effect.promise(() => q.select({ id: costEventsTable.id }).from(costEventsTable).where(condition).limit(1))).length > 0;
+	});
+	const record = (event, opts) => Effect.gen(function* () {
+		if (opts?.dryRun) {
+			if (yield* checkDuplicate(event)) return false;
+			return true;
+		}
+		yield* archive.append(event);
+		if (yield* checkDuplicate(event)) return false;
+		yield* Effect.promise(() => q.insert(costEventsTable).values({
+			ts: event.ts,
+			issueId: event.issueId,
+			agentId: event.agentId,
+			sessionId: event.sessionId,
+			sessionType: event.sessionType,
+			provider: event.provider,
+			model: event.model,
+			input: event.input,
+			output: event.output,
+			cacheRead: event.cacheRead,
+			cacheWrite: event.cacheWrite,
+			cost: event.cost,
+			requestId: event.requestId,
+			sourceFile: event.sourceFile
+		}).onConflictDoNothing());
+		if (event.agentId && event.issueId) yield* bus.emit({
+			type: "cost.event_recorded",
+			payload: {
+				agentId: event.agentId,
+				issueId: event.issueId,
+				cost: event.cost,
+				inputTokens: event.input,
+				outputTokens: event.output
+			}
+		});
+		return true;
+	});
+	const reconcile = (opts) => Effect.gen(function* () {
+		const source = opts?.source ?? "claude";
+		const empty = {
+			imported: 0,
+			cacheSkipped: 0,
+			skipped: [],
+			sessionsScanned: 0,
+			eventsImported: 0,
+			duplicatesSkipped: 0,
+			errors: [],
+			earliestEventTs: null,
+			latestEventTs: null,
+			warnings: []
+		};
+		if (source !== "ohmypi" && source !== "codex") return empty;
+		if (source === "codex") {
+			const collected = yield* Effect.promise(() => collectCodexCostEvents(opts));
+			let imported = 0;
+			let duplicatesSkipped = 0;
+			let earliestEventTs = null;
+			let latestEventTs = null;
+			for (const skipped of collected.skipped) console.warn(`[cost-reconcile] skipped ${skipped.file}: ${skipped.reason}`);
+			for (const event of collected.events) if (yield* record(event, { dryRun: opts?.dryRun })) {
+				imported++;
+				const iso = event.ts.toISOString();
+				if (earliestEventTs == null || iso < earliestEventTs) earliestEventTs = iso;
+				if (latestEventTs == null || iso > latestEventTs) latestEventTs = iso;
+			} else duplicatesSkipped++;
+			if (!opts?.dryRun) for (const verdict of collected.verdicts) recordSkipVerdict(verdict.path, verdict.mtimeMs, verdict.size, verdict.verdict);
+			return {
+				imported,
+				cacheSkipped: collected.stats.cacheSkipped,
+				skipped: collected.skipped,
+				sessionsScanned: collected.stats.scanned,
+				eventsImported: imported,
+				duplicatesSkipped,
+				errors: collected.errors,
+				earliestEventTs,
+				latestEventTs,
+				warnings: []
+			};
+		}
+		const agentsDir = join(getOverdeckHome(), "agents");
+		const agentNames = yield* Effect.sync(() => {
+			if (!existsSync(agentsDir)) return [];
+			return readdirSync(agentsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+		});
+		let imported = 0;
+		let cacheSkipped = 0;
+		const skipped = [];
+		let duplicatesSkipped = 0;
+		let sessionsScanned = 0;
+		let earliestEventTs = null;
+		let latestEventTs = null;
+		const errors = [];
+		const warnings = [];
+		const markSkipped = (file, reason) => {
+			skipped.push({
+				file,
+				reason
+			});
+			console.warn(`[cost-reconcile] skipped ${file}: ${reason}`);
+		};
+		const markWarning = (warning) => {
+			warnings.push(warning);
+			console.warn(`[cost-reconcile] warning ${warning.file}: ${warning.reason} provider=${warning.provider ?? "unknown"} model=${warning.model}`);
+		};
+		const noteImportedTimestamp = (ts) => {
+			const iso = ts.toISOString();
+			if (earliestEventTs == null || iso < earliestEventTs) earliestEventTs = iso;
+			if (latestEventTs == null || iso > latestEventTs) latestEventTs = iso;
+		};
+		const roots = agentNames.map((agentName) => ({
+			root: join(agentsDir, agentName, "sessions"),
+			agentName,
+			issueId: issueIdFromAgentName(agentName),
+			sessionType: "ohmypi"
+		}));
+		for (const extra of opts?.extraRootSpecs ?? []) {
+			if (source === "ohmypi" && extra.kind === "ohmypi-global") {
+				const encodedRoots = yield* Effect.sync(() => {
+					if (!existsSync(extra.root)) return [];
+					return readdirSync(extra.root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => ({
+						root: join(extra.root, e.name),
+						agentName: "pi-global",
+						issueId: inferIssueFromPiEncodedRootName(e.name) ?? "UNKNOWN",
+						sessionType: "ohmypi"
+					}));
+				});
+				roots.push(...encodedRoots);
+			}
+			if (source === "ohmypi" && extra.kind === "ohmypi-legacy-agents") {
+				const legacyRoots = yield* Effect.sync(() => {
+					if (!existsSync(extra.root)) return [];
+					return readdirSync(extra.root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => ({
+						root: join(extra.root, e.name, "sessions"),
+						agentName: e.name,
+						issueId: issueIdFromAgentName(e.name),
+						sessionType: "ohmypi"
+					}));
+				});
+				roots.push(...legacyRoots);
+			}
+		}
+		for (const root of roots) {
+			const sessionFiles = yield* Effect.sync(() => walkJsonl(root.root));
+			for (const sessionFile of sessionFiles) {
+				sessionsScanned++;
+				if (source === "ohmypi") {
+					const parsed = yield* Effect.sync(() => {
+						try {
+							return parseOhmypiSessionCostResultSync(sessionFile);
+						} catch (cause) {
+							const reason = cause instanceof Error ? cause.message : String(cause);
+							errors.push(`${sessionFile}: ${reason}`);
+							return {
+								ok: false,
+								reason
+							};
+						}
+					});
+					if (!parsed.ok) {
+						markSkipped(sessionFile, parsed.reason ?? "unreadable");
+						continue;
+					}
+					const events = parsed.usageEvents ?? [];
+					if (events.length === 0) {
+						markSkipped(sessionFile, "no-usage");
+						continue;
+					}
+					const unpricedWarnings = parsed.unpricedModels ?? [];
+					if (unpricedWarnings.length) markSkipped(sessionFile, "unpriced-model");
+					for (const usage of events) {
+						const derivedWarnings = unpricedWarnings.filter((warning) => warning.model === usage.model && warning.provider === usage.provider).map((warning) => ({
+							type: "unpriced-model",
+							...warning
+						}));
+						const eventWarnings = usage.warnings?.length ? usage.warnings : derivedWarnings;
+						for (const warning of eventWarnings) markWarning({
+							file: sessionFile,
+							reason: warning.reason,
+							provider: warning.provider,
+							model: warning.model
+						});
+						const ts = new Date(usage.timestamp);
+						if (yield* record({
+							ts,
+							issueId: root.issueId,
+							agentId: root.agentName,
+							sessionId: usage.sessionId,
+							sessionType: root.sessionType,
+							provider: inferPiProvider(usage.model, usage.provider),
+							model: usage.model,
+							input: usage.input,
+							output: usage.output,
+							cacheRead: usage.cacheRead,
+							cacheWrite: usage.cacheWrite,
+							cost: usage.cost,
+							requestId: usage.requestId,
+							sourceFile: sessionFile,
+							warnings: eventWarnings.length > 0 ? eventWarnings : void 0
+						}, { dryRun: opts?.dryRun })) {
+							imported++;
+							noteImportedTimestamp(ts);
+						} else duplicatesSkipped++;
+					}
+					continue;
+				}
+			}
+		}
+		return {
+			imported,
+			cacheSkipped,
+			skipped,
+			sessionsScanned,
+			eventsImported: imported,
+			duplicatesSkipped,
+			errors,
+			earliestEventTs,
+			latestEventTs,
+			warnings
+		};
+	});
+	const rebuild = () => Effect.gen(function* () {
+		return { events: 0 };
+	});
+	const createBudget = (spec) => Effect.gen(function* () {
+		return mapBudget(yield* Effect.sync(() => createBudgetSync({
+			...spec,
+			enabled: true
+		})));
+	});
+	const deleteBudget = (id) => Effect.gen(function* () {
+		if (!(yield* Effect.sync(() => deleteBudgetSync(id)))) return yield* Effect.fail(new BudgetNotFound({ id }));
+	});
+	return CostWriter.of({
+		record,
+		reconcile,
+		rebuild,
+		createBudget,
+		deleteBudget
+	});
+})).pipe(Layer.provide(Layer.mergeAll(DbLive, EventBusLive.pipe(Layer.provide(DbLive)), CostArchiveLive)));
+HttpApiGroup.make("costs").add(HttpApiEndpoint.get("summary", "/costs/summary", {
+	query: {
+		window: Schema.optional(Window),
+		project: Schema.optional(Schema.String)
+	},
+	success: WindowSummary
+})).add(HttpApiEndpoint.get("byIssue", "/costs/by-issue", { success: Schema.Array(Rollup) })).add(HttpApiEndpoint.get("issueDetail", "/costs/issue/:id", {
+	params: { id: IssueId },
+	success: IssueCost
+})).add(HttpApiEndpoint.get("byDay", "/costs/trends", {
+	query: {
+		days: Schema.optional(Schema.NumberFromString),
+		issueId: Schema.optional(IssueId)
+	},
+	success: Schema.Array(Rollup)
+})).add(HttpApiEndpoint.get("byModel", "/costs/by-model", {
+	query: { issueId: Schema.optional(IssueId) },
+	success: Schema.Array(Rollup)
+})).add(HttpApiEndpoint.get("byAgent", "/costs/by-agent", {
+	query: { issueId: Schema.optional(IssueId) },
+	success: Schema.Array(Rollup)
+})).add(HttpApiEndpoint.get("byBackgroundSource", "/costs/background", {
+	query: { hours: Schema.optional(Schema.NumberFromString) },
+	success: Schema.Array(Rollup)
+})).add(HttpApiEndpoint.get("byProject", "/costs/by-project", { success: Schema.Array(Rollup) })).add(HttpApiEndpoint.get("recent", "/costs/stream", {
+	query: {
+		limit: Schema.optional(Schema.NumberFromString),
+		since: Schema.optional(Schema.String)
+	},
+	success: Schema.Array(CostEvent)
+})).add(HttpApiEndpoint.get("listBudgets", "/costs/budget", { success: Schema.Array(Budget) })).add(HttpApiEndpoint.get("checkBudget", "/costs/budget/:id", {
+	params: { id: Schema.String },
+	success: BudgetStatus,
+	error: BudgetNotFound
+})).add(HttpApiEndpoint.post("reconcile", "/costs/reconcile", {
+	payload: Schema.Struct({
+		source: Schema.optional(Schema.Literals([
+			"claude",
+			"ohmypi",
+			"codex",
+			"acp",
+			"wal"
+		])),
+		dryRun: Schema.optional(Schema.Boolean),
+		extraRoots: Schema.optional(Schema.Array(Schema.String))
+	}),
+	success: Schema.Struct({
+		imported: Schema.Number,
+		skipped: Schema.Array(Schema.Struct({
+			file: Schema.String,
+			reason: Schema.String
+		})),
+		sessionsScanned: Schema.Number,
+		eventsImported: Schema.Number,
+		duplicatesSkipped: Schema.Number,
+		errors: Schema.Array(Schema.String),
+		earliestEventTs: Schema.NullOr(Schema.String),
+		latestEventTs: Schema.NullOr(Schema.String),
+		warnings: Schema.Array(Schema.Struct({
+			file: Schema.String,
+			reason: Schema.String,
+			provider: Schema.NullOr(Schema.String),
+			model: Schema.String
+		}))
+	}),
+	error: CostIngestError
+})).add(HttpApiEndpoint.post("rebuild", "/costs/rebuild", {
+	success: Schema.Struct({ events: Schema.Number }),
+	error: CostIngestError
+})).add(HttpApiEndpoint.post("createBudget", "/costs/budget", {
+	payload: BudgetSpec,
+	success: Budget,
+	error: CostIngestError
+})).add(HttpApiEndpoint["delete"]("deleteBudget", "/costs/budget/:id", {
+	params: { id: Schema.String },
+	error: BudgetNotFound
+}));
+//#endregion
+export { collectCodexCostEvents as a, CostWriter as i, CostResolver as n, lookupSkipVerdict as o, CostResolverLive as r, recordSkipVerdict as s, CostDoorLive as t };
+
+//# sourceMappingURL=cost-3FyqKK56.js.map