[8] Report PR costs as work progresses

.github/workflows/tui-e2e.yml

@@ -47,6 +47,13 @@ jobs:
           go-version-file: tools/proxy-helper/go.mod
           cache-dependency-path: tools/proxy-helper/go.sum
 
+      # Fresh test homes otherwise download these before the editor accepts input.
+      - name: Install search tools
+        timeout-minutes: 3
+        run: |
+          sudo apt-get update -qq
+          sudo apt-get install --yes --no-install-recommends ripgrep fd-find
+
       - name: Build proxy-helper
         run: make copy-for-dev # Builds the binary and copies it to bin/ where the tests expect it
         working-directory: tools/proxy-helper

docs/work-attribution.md

@@ -473,7 +473,7 @@ The footer and Ferment budgets have different token scopes. Ferment V2 counts pa
 
 ## Turning Cost per PR off
 
-Cost per PR is listed in `/resources` like other built-in extensions and is on by default. Disabling it there, or with `kimchi resources disable extensions.cost-per-pr`, takes effect at the next start: Kimchi records no work, looks up no PRs and shows no `/work` or PR/MR status. Other extensions stop recording work at once. Records already saved stay on disk.
+Cost per PR is listed in `/resources` like other built-in extensions and is on by default. Disabling it there, or with `kimchi resources disable extensions.cost-per-pr`, takes effect at the next start: Kimchi records no work, looks up no PRs, shows no `/work` or PR/MR status and uploads no PR cost reports. Other extensions stop recording work at once. Records already saved stay on disk.
 
 ## What still needs work
 

src/cli.ts

@@ -118,6 +118,7 @@ import piiRedactionExtension from "./extensions/pii-redaction/index.js"
 import plannotatorExtension from "./extensions/plannotator/index.js"
 import pluginPackageHooksAdapter from "./extensions/plugin-package-hook-adapter/index.js"
 import powershellGateExtension from "./extensions/powershell-gate.js"
+import prCostReportingExtension from "./extensions/pr-cost-reporting/index.js"
 import { setPrintGate } from "./extensions/print-mode.js"
 import promptEnrichmentExtension from "./extensions/prompt-construction/prompt-enrichment.js"
 import promptSummaryExtension from "./extensions/prompt-summary.js"
@@ -837,6 +838,7 @@ try {
 			...enabledExtensionFactories([
 				{ id: COST_PER_PR_RESOURCE_ID, factory: createWorkAttributionExtension() },
 				{ id: COST_PER_PR_RESOURCE_ID, factory: pullRequestStatusExtension },
+				{ id: COST_PER_PR_RESOURCE_ID, factory: prCostReportingExtension },
 			] satisfies ManagedExtensionFactory[]),
 			requestTimingExtension,
 			llmResponseLogExtension,

src/config.test.ts

@@ -30,6 +30,7 @@ import {
 	writeHideTips,
 	writeSessionModeWizardSeenAt,
 	writeStudioOnboardingSeenAt,
+	writeTelemetryEnabled,
 	writeTeleportCompactHintEnabled,
 	writeTuiWheelScrollLines,
 } from "./config.js"
@@ -1032,6 +1033,21 @@ describe("readTelemetryConfig", () => {
 		expect(config.metricsEndpoint).toBe("https://custom.example.com/metrics:ingest")
 	})
 
+	it("persists consent changes across off/on while repeated on keeps the current version", () => {
+		writeFileSync(configPath, JSON.stringify({ telemetry: { enabled: true } }))
+		expect(readTelemetryConfig(configPath).consentVersion).toBeUndefined()
+		writeTelemetryEnabled(false, configPath)
+		const disabled = readTelemetryConfig(configPath)
+		expect(disabled.enabled).toBe(false)
+		expect(disabled.consentVersion).toEqual(expect.any(String))
+		writeTelemetryEnabled(true, configPath)
+		const enabled = readTelemetryConfig(configPath)
+		expect(enabled.enabled).toBe(true)
+		expect(enabled.consentVersion).not.toBe(disabled.consentVersion)
+		writeTelemetryEnabled(true, configPath)
+		expect(readTelemetryConfig(configPath).consentVersion).toBe(enabled.consentVersion)
+	})
+
 	it("falls back to default metrics endpoint when absent", () => {
 		writeFileSync(
 			configPath,

src/config.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto"
 import { existsSync, readFileSync, statSync } from "node:fs"
 import { homedir } from "node:os"
 import { join, relative, resolve } from "node:path"
@@ -95,6 +96,7 @@ export function buildSkillPathOptions(discoveredDirs: string[]): string[] {
 
 export interface TelemetryConfig {
 	enabled: boolean
+	consentVersion?: string
 	endpoint: string
 	metricsEndpoint: string
 	headers: Record<string, string>
@@ -524,6 +526,7 @@ export function readTelemetryConfig(configPath?: string): TelemetryConfig {
 	const path = configPath ?? KIMCHI_CONFIG_PATH
 	const envEnabled = process.env.KIMCHI_TELEMETRY_ENABLED
 	let fileEnabled: boolean | undefined
+	let fileConsentVersion: string | undefined
 	let fileEndpoint: string | undefined
 	let fileMetricsEndpoint: string | undefined
 	let fileHeaders: Record<string, string> | undefined
@@ -538,6 +541,7 @@ export function readTelemetryConfig(configPath?: string): TelemetryConfig {
 		const t = parsed.telemetry
 		if (t && typeof t === "object") {
 			if (typeof t.enabled === "boolean") fileEnabled = t.enabled
+			if (typeof t.consentVersion === "string") fileConsentVersion = t.consentVersion
 			if (typeof t.endpoint === "string" && t.endpoint.length > 0) fileEndpoint = t.endpoint
 			if (typeof t.metricsEndpoint === "string" && t.metricsEndpoint.length > 0) fileMetricsEndpoint = t.metricsEndpoint
 			if (t.headers && typeof t.headers === "object" && !Array.isArray(t.headers)) {
@@ -579,6 +583,7 @@ export function readTelemetryConfig(configPath?: string): TelemetryConfig {
 
 	return {
 		enabled,
+		consentVersion: fileConsentVersion,
 		endpoint: fileEndpoint ?? telemetryLogsUrl(region),
 		metricsEndpoint: fileMetricsEndpoint ?? telemetryMetricsUrl(region),
 		headers,
@@ -1143,6 +1148,8 @@ export function writeTelemetryEnabled(enabled: boolean, configPath?: string): vo
 	const path = configPath ?? KIMCHI_CONFIG_PATH
 	updateConfigFile(path, (raw) => {
 		const t = (raw.telemetry as Record<string, unknown> | undefined) ?? {}
+		// A different process may turn telemetry off and on between export attempts.
+		if (t.enabled !== enabled) t.consentVersion = randomUUID()
 		t.enabled = enabled
 		raw.telemetry = t
 	})

src/extensions/pr-cost-reporting/agreement.test.ts

@@ -0,0 +1,135 @@
+import { readFileSync } from "node:fs"
+import { afterEach, beforeEach, expect, it, vi } from "vitest"
+import type { WorkPullRequest } from "../pull-request-status/pull-requests.js"
+import { calculatePullRequestCosts, decimalNanos, usd } from "../work-attribution/costs.js"
+import type { WorkRecord } from "../work-attribution/summary.js"
+import { buildSnapshots } from "./snapshot.js"
+
+// The backend checks the same content in services/ai-optimizer/internal/services/prcosts/testdata/client-agreement.golden.
+// Update both copies together: they pin where /work and the console must agree.
+const account = {
+	apiUrl: "https://api.example",
+	organizationId: "11111111-1111-4111-8111-111111111111",
+	userId: "22222222-2222-4222-8222-222222222222",
+}
+const started = "2026-10-04T12:00:00.000Z"
+const merged = "2026-10-04T13:00:00.000Z"
+const repositories = new Map([
+	["/repo-a/.git", { provider: "github" as const, host: "github.com", id: "42", name: "example/a" }],
+	["/repo-b/.git", { provider: "github" as const, host: "github.com", id: "43", name: "example/b" }],
+])
+beforeEach(() => {
+	vi.useFakeTimers({ toFake: ["Date"] })
+	vi.setSystemTime(new Date("2026-10-07T12:00:00Z"))
+})
+afterEach(() => vi.useRealTimers())
+
+const id = (prefix: string, n: number) => `${prefix}0000000-0000-4000-8000-00000000000${n}`
+function pull(number: number, repository: "a" | "b"): WorkPullRequest {
+	return {
+		provider: "github",
+		id: String(number),
+		repositoryId: repository === "a" ? "42" : "43",
+		host: "github.com",
+		repository: `example/${repository}`,
+		number,
+		url: `https://github.com/example/${repository}/pull/${number}`,
+		state: "merged",
+		mergedAt: merged,
+		closedAt: merged,
+		checkedAt: merged,
+		headSha: "a".repeat(40),
+		mergeCommitSha: "b".repeat(40),
+	}
+}
+function work(n: number, pulls: [WorkPullRequest, "a" | "b"][]): WorkRecord[] {
+	return pulls.map(([pr, repository], index) => ({
+		version: 1,
+		type: "commit",
+		workId: id("1", n),
+		sessionId: "session",
+		sha: String(n * 10 + index).padStart(40, "0"),
+		repository: `/repo-${repository}/.git`,
+		worktree: `/repo-${repository}`,
+		recordedAt: merged,
+		pullRequests: [pr],
+	}))
+}
+function request(n: number, workNumber: number, attribution: string, startedAt = started): WorkRecord {
+	return {
+		version: 1,
+		type: "request",
+		workId: id("1", workNumber),
+		sessionId: "session",
+		requestId: id("2", n),
+		startedAt,
+		recordedAt: startedAt,
+		scope: { account, repository: "/repo-a/.git" },
+		segment: { id: `segment-${n}`, attribution, reason: attribution },
+	}
+}
+
+it("pins the PR totals that /work and the console must agree on", () => {
+	const records = [
+		// 101: confirmed spend, a verified no-charge attempt and later post-merge work.
+		...work(1, [[pull(101, "a"), "a"]]),
+		request(1, 1, "explicit"),
+		request(6, 1, "explicit"),
+		request(7, 1, "explicit", "2026-10-04T14:00:00.000Z"),
+		// 102: a model match is inferred spend.
+		...work(2, [[pull(102, "a"), "a"]]),
+		request(2, 2, "inferred"),
+		// Unresolved matching with no candidate PR leaves every PR complete.
+		request(3, 3, "unknown"),
+		// 103: an explicit attempt with no bill yet stays on its PR, which stays incomplete until the bill arrives.
+		...work(4, [[pull(103, "a"), "a"]]),
+		request(4, 4, "explicit"),
+		// 104 and 201: one attempt shared across repositories is counted once and leaves both incomplete.
+		...work(5, [
+			[pull(104, "a"), "a"],
+			[pull(201, "b"), "b"],
+		]),
+		request(5, 5, "explicit"),
+	]
+	const bills = [
+		{ request: 1, costUsd: "1.25" },
+		{ request: 2, costUsd: "2" },
+		{ request: 3, costUsd: "3" },
+		{ request: 5, costUsd: "5" },
+		{ request: 7, costUsd: "7" },
+	].map(({ request, costUsd }) => ({
+		requestId: id("2", request),
+		billingRecordId: id("3", request),
+		costUsd,
+		account,
+	}))
+	const noCharge = new Map([[id("2", 6), account]])
+	const report = calculatePullRequestCosts(records, bills, new Set(), noCharge)
+	const { snapshots, incomplete } = buildSnapshots(records, report, repositories)
+	expect(incomplete).toBe(false)
+	// Each attempt appears once in the request list, whichever bucket or PR it belongs to.
+	const organizationNanos = report.requests.reduce((sum, row) => sum + (decimalNanos(row.knownCostUsd) ?? 0n), 0n)
+	const fixture = {
+		actorId: account.userId,
+		snapshots: snapshots.map((snapshot, index) => ({
+			schemaVersion: 1,
+			producerId: id("4", index + 1),
+			revision: "1",
+			generatedAt: "2026-10-07T12:00:00.000Z",
+			...snapshot.content,
+		})),
+		bills: bills.map((bill) => ({ id: bill.billingRecordId, ownerId: account.userId, totalPrice: bill.costUsd })),
+		noChargeRequestIds: [...noCharge.keys()],
+		organizationKnownCostUsd: usd(organizationNanos),
+		pullRequests: report.pullRequests
+			.map((pr) => ({
+				repositoryId: pr.pullRequest?.repositoryId,
+				id: pr.pullRequest?.id,
+				knownCostUsd: pr.knownCostUsd,
+				complete: pr.totalCostUsd !== null,
+			}))
+			.sort((a, b) => `${a.repositoryId}/${a.id}`.localeCompare(`${b.repositoryId}/${b.id}`)),
+	}
+	const committed = JSON.parse(readFileSync(new URL("./client-agreement.json", import.meta.url), "utf8"))
+	expect(fixture).toEqual(committed)
+})

src/extensions/pr-cost-reporting/automation.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest"
+import { uploadSkipReason } from "./automation.js"
+
+describe("PR cost uploads from automated runs", () => {
+	it.each(["tui", "rpc"] as const)("lets an interactive %s session upload", (mode) => {
+		expect(uploadSkipReason(mode, {})).toBeUndefined()
+	})
+	it.each([
+		["print", "non-interactive print mode"],
+		["json", "non-interactive JSON mode"],
+	] as const)("skips a one-shot %s run", (mode, reason) => {
+		expect(uploadSkipReason(mode, {})).toBe(reason)
+	})
+	it.each([
+		"CI",
+		"GITHUB_ACTIONS",
+		"GITLAB_CI",
+		"BUILDKITE",
+		"JENKINS_URL",
+		"TEAMCITY_VERSION",
+		"CIRCLECI",
+		"TF_BUILD",
+	])("skips a CI job detected through %s", (name) => {
+		expect(uploadSkipReason("tui", { [name]: name === "JENKINS_URL" ? "https://jenkins.example/" : "true" })).toBe(
+			`CI environment (${name})`,
+		)
+	})
+	it.each(["", " ", "0", "false", "FALSE"])("treats CI=%j as a developer terminal", (value) => {
+		expect(uploadSkipReason("tui", { CI: value })).toBeUndefined()
+	})
+	it.each(["0", "false", "off", "no"])("honors KIMCHI_PR_COST_REPORTING=%s in every mode", (value) => {
+		expect(uploadSkipReason("rpc", { KIMCHI_PR_COST_REPORTING: value })).toBe("KIMCHI_PR_COST_REPORTING=0")
+	})
+	it("offers no way around CI detection", () => {
+		expect(uploadSkipReason("tui", { KIMCHI_PR_COST_REPORTING: "1", CI: "true" })).toBe("CI environment (CI)")
+	})
+	it("skips benchmark runs, the only users of the infrastructure breaker", () => {
+		expect(uploadSkipReason("tui", { KIMCHI_INFRA_BREAKER_THRESHOLD: "3" })).toBe(
+			"benchmark run (KIMCHI_INFRA_BREAKER_THRESHOLD)",
+		)
+		expect(uploadSkipReason("tui", { KIMCHI_INFRA_BREAKER_THRESHOLD: "0" })).toBeUndefined()
+	})
+})

src/extensions/pr-cost-reporting/automation.ts

@@ -0,0 +1,30 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent"
+import { INFRA_BREAKER_THRESHOLD_ENV, resolveInfrastructureBreakerThreshold } from "../../upstream-retry-patch.js"
+
+export const CI_VARIABLES = [
+	"CI",
+	"GITHUB_ACTIONS",
+	"GITLAB_CI",
+	"BUILDKITE",
+	"JENKINS_URL",
+	"TEAMCITY_VERSION",
+	"CIRCLECI",
+	"TF_BUILD",
+]
+
+const disabled = (value: string | undefined) => ["0", "false", "off", "no"].includes(value?.trim().toLowerCase() ?? "")
+
+/**
+ * Why this process must not upload PR costs, or undefined when it may. CI, one-shot print or JSON runs
+ * and benchmarks (the only callers of the infrastructure breaker) would report noise. Interactive TUI,
+ * ACP and RPC sessions still report. Local attribution runs either way.
+ */
+export function uploadSkipReason(mode: ExtensionContext["mode"], env = process.env): string | undefined {
+	if (disabled(env.KIMCHI_PR_COST_REPORTING)) return "KIMCHI_PR_COST_REPORTING=0"
+	if (mode === "print") return "non-interactive print mode"
+	if (mode === "json") return "non-interactive JSON mode"
+	const ci = CI_VARIABLES.find((name) => env[name]?.trim() && !disabled(env[name]))
+	if (ci) return `CI environment (${ci})`
+	if (resolveInfrastructureBreakerThreshold(env) > 0) return `benchmark run (${INFRA_BREAKER_THRESHOLD_ENV})`
+	return undefined
+}