loki-mode 10.7.1 → 10.9.1

package/packages/control-plane/src/server/routes/cost_ledger.ts

@@ -0,0 +1,210 @@
+// CPE24-P1: the per-checkout cost ledger, ported from dashboard/server.py (/api/cost, /api/cost/timeline). Same on-disk sources:
+// <repo>/.loki/metrics/efficiency/iteration-*.json, metrics/budget.json, context/tracking.json, proofs/<run>/proof.json, pricing.json.
+// Honest data: a present record is not a measurement. Anything not measured is null, never a summed 0.
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { probeAllowed, type RouteCtx } from "./index.ts";
+
+type Rec = Record<string, unknown>;
+const isNum = (v: unknown): v is number => typeof v === "number" && Number.isFinite(v);
+const isObj = (v: unknown): v is Rec => typeof v === "object" && v !== null && !Array.isArray(v);
+const r6 = (n: number) => Math.round(n * 1e6) / 1e6;
+
+export const MEASURED_FIELDS = ["cost_usd", "input_tokens", "output_tokens", "cache_read_tokens", "cache_creation_tokens"] as const;
+export const BUDGET_WARN_FRACTION = 0.8;
+export const NOT_MEASURED = "not measured";
+
+export function readJson(path: string): unknown {
+  try { return JSON.parse(readFileSync(path, "utf8")); } catch { return null; }
+}
+
+/** One record carries an observed (non-zero numeric) value in at least one measured field; mirrors autonomy/lib/efficiency_cost.py record_is_measured. */
+export function recordIsMeasured(rec: unknown, skip?: string): boolean {
+  if (!isObj(rec)) return false;
+  return MEASURED_FIELDS.some((k) => k !== skip && isNum(rec[k]) && rec[k] !== 0);
+}
+
+const DEFAULT_PRICING: Record<string, Rec> = {
+  fable: { input: 10, output: 50 }, "claude-fable-5": { input: 10, output: 50 },
+  opus: { input: 5, output: 25 }, sonnet: { input: 2, output: 10 }, haiku: { input: 1, output: 5 },
+  "gpt-5.3-codex": { input: 1.5, output: 12 },
+  "gpt-5.6-sol": { input: 2.5, output: 20 }, "gpt-5.6-terra": { input: 1.5, output: 12 }, "gpt-5.6-luna": { input: 0.5, output: 4 },
+};
+
+function pricing(lokiDir: string): Record<string, Rec> {
+  const d = readJson(join(lokiDir, "pricing.json"));
+  const models = isObj(d) && isObj(d.models) ? (d.models as Record<string, Rec>) : {};
+  return { ...DEFAULT_PRICING, ...models };
+}
+
+/** Token-priced USD with cache tiers; an unpriced cache tier falls back to the input rate (over-state, never under-count). */
+export function modelCost(table: Record<string, Rec>, model: string, inp: number, out: number, cr = 0, cw = 0): number {
+  const p = table[model.toLowerCase()] ?? table.sonnet ?? {};
+  const ir = isNum(p.input) ? p.input : 3;
+  const or = isNum(p.output) ? p.output : 15;
+  const crr = isNum(p.cache_read) ? p.cache_read : ir * 0.1;
+  const cwr = isNum(p.cache_write) ? p.cache_write : ir * 1.25;
+  return r6((inp * ir + out * or + cr * crr + cw * cwr) / 1e6);
+}
+
+/** Parsed iteration-*.json records in filename order (the file set the budget breaker reads). */
+export function iterationRecords(lokiDir: string): Rec[] {
+  const dir = join(lokiDir, "metrics", "efficiency");
+  let names: string[] = [];
+  try { names = readdirSync(dir).filter((n) => /^iteration-.*\.json$/.test(n)).sort(); } catch { return []; }
+  const out: Rec[] = [];
+  for (const n of names) { const d = readJson(join(dir, n)); if (isObj(d)) out.push(d); }
+  return out;
+}
+
+const num0 = (v: unknown) => (isNum(v) ? v : 0);
+const priced = (table: Record<string, Rec>, d: Rec) =>
+  d.cost_usd === null || d.cost_usd === undefined
+    ? modelCost(table, String(d.model ?? "sonnet").toLowerCase(), num0(d.input_tokens), num0(d.output_tokens), num0(d.cache_read_tokens), num0(d.cache_creation_tokens))
+    : num0(d.cost_usd);
+
+interface Bucket { input_tokens: number; output_tokens: number; cost_usd: number; measured: boolean; tokens_measured: boolean }
+
+export function costSnapshot(lokiDir: string) {
+  const table = pricing(lokiDir);
+  let tIn = 0, tOut = 0, tCr = 0, tCw = 0, est = 0;
+  let recorded = false, unknownUsd = false;
+  const byPhase: Record<string, Bucket> = {}, byModel: Record<string, Bucket> = {};
+  for (const d of iterationRecords(lokiDir)) {
+    const measured = recordIsMeasured(d);
+    if (measured) recorded = true;
+    const tokMeasured = recordIsMeasured(d, "cost_usd");
+    const inp = num0(d.input_tokens), out = num0(d.output_tokens), cr = num0(d.cache_read_tokens), cw = num0(d.cache_creation_tokens);
+    const model = String(d.model ?? "sonnet").toLowerCase();
+    const phase = String(d.phase ?? "unknown");
+    tIn += inp; tOut += out; tCr += cr; tCw += cw;
+    const cost = priced(table, d);
+    est += cost;
+    for (const [bucket, name] of [[byPhase, phase], [byModel, model]] as const) {
+      const b = (bucket[name] ??= { input_tokens: 0, output_tokens: 0, cost_usd: 0, measured: false, tokens_measured: false });
+      b.input_tokens += inp; b.output_tokens += out; b.cost_usd += cost;
+      b.measured ||= measured; b.tokens_measured ||= tokMeasured;
+    }
+  }
+  if (tIn === 0 && tOut === 0) {
+    const ctx = readJson(join(lokiDir, "context", "tracking.json"));
+    const totals = isObj(ctx) && isObj(ctx.totals) ? ctx.totals : {};
+    tIn = num0(totals.total_input); tOut = num0(totals.total_output);
+    if (tIn > 0 || tOut > 0) {
+      recorded = true;
+      if (isNum(totals.total_cost_usd)) est = totals.total_cost_usd; else unknownUsd = true;
+      const model = String((isObj(ctx) && ctx.provider) || "unknown").toLowerCase();
+      const per = isObj(ctx) && Array.isArray(ctx.per_iteration) ? ctx.per_iteration : [];
+      for (const it of per) {
+        if (!isObj(it)) continue;
+        const b = (byModel[model] ??= { input_tokens: 0, output_tokens: 0, cost_usd: 0, measured: false, tokens_measured: true });
+        b.input_tokens += num0(it.input_tokens); b.output_tokens += num0(it.output_tokens);
+        if (isNum(it.cost_usd)) { b.cost_usd += it.cost_usd; b.measured = true; }
+      }
+    }
+  }
+  let limit: number | null = null, used: number | null = null, remaining: number | null = null;
+  const bd = readJson(join(lokiDir, "metrics", "budget.json"));
+  if (isObj(bd) && isNum(bd.limit)) {
+    limit = bd.limit;
+    if (recorded && !unknownUsd) { used = est; remaining = Math.max(0, limit - used); }
+  }
+  const readIn = tIn + tCr;
+  const fmt = (m: Record<string, Bucket>) => Object.fromEntries(Object.entries(m).map(([k, v]) => [k, {
+    input_tokens: v.tokens_measured ? v.input_tokens : null, output_tokens: v.tokens_measured ? v.output_tokens : null,
+    cost_usd: v.measured ? r6(v.cost_usd) : null,
+  }]));
+  return {
+    total_input_tokens: recorded ? tIn : null, total_output_tokens: recorded ? tOut : null,
+    total_cache_read_tokens: recorded ? tCr : null, total_cache_creation_tokens: recorded ? tCw : null,
+    total_tokens: recorded ? tIn + tOut + tCr + tCw : null,
+    cache_hit_ratio: readIn > 0 ? Math.round((tCr / readIn) * 1e4) / 1e4 : null,
+    estimated_cost_usd: recorded && !unknownUsd ? r6(est) : null,
+    cost_recorded: recorded,
+    by_phase: fmt(byPhase), by_model: fmt(byModel),
+    budget_limit: limit, budget_used: limit !== null && used !== null ? r6(used) : null, budget_remaining: remaining !== null ? r6(remaining) : null,
+    ...(recorded ? {} : { not_measured: NOT_MEASURED }),
+  };
+}
+
+export function budgetStatus(used: number | null, limit: number | null): "none" | "unknown" | "ok" | "warn" | "exceeded" {
+  if (limit === null || limit <= 0) return "none";
+  if (used === null) return "unknown";
+  if (used >= limit) return "exceeded";
+  return used >= BUDGET_WARN_FRACTION * limit ? "warn" : "ok";
+}
+
+export function budgetSnapshot(lokiDir: string) {
+  const table = pricing(lokiDir);
+  let total = 0, recorded = false, unmeasured = 0;
+  for (const d of iterationRecords(lokiDir)) {
+    if (recordIsMeasured(d)) recorded = true; else unmeasured++;
+    total += priced(table, d);
+  }
+  let limit: number | null = null;
+  const bd = readJson(join(lokiDir, "metrics", "budget.json"));
+  if (isObj(bd)) { const l = bd.limit || bd.budget_limit; limit = isNum(l) ? l : null; }
+  if (limit === null && process.env.LOKI_BUDGET_LIMIT) { const e = Number(process.env.LOKI_BUDGET_LIMIT); if (Number.isFinite(e)) limit = e; }
+  const used = recorded ? r6(total) : null;
+  const ok = limit !== null && limit > 0 && used !== null;
+  const status = budgetStatus(used, limit);
+  return {
+    limit, used, remaining: ok ? r6(Math.max(0, limit! - used!)) : null, percent_used: ok ? Math.round((used! / limit!) * 1e4) / 100 : null,
+    status, warn_threshold_percent: Math.round(BUDGET_WARN_FRACTION * 100), exceeded: status === "exceeded", partial: recorded && unmeasured > 0,
+  };
+}
+
+export function costTimeline(lokiDir: string) {
+  const table = pricing(lokiDir);
+  const recs = iterationRecords(lokiDir).map((d, i) => ({ d, i }))
+    .sort((a, b) => (num0(Number(a.d.iteration)) - num0(Number(b.d.iteration))) || a.i - b.i).map((x) => x.d);
+  const iterations: Rec[] = [];
+  let cum = 0, recorded = false, unmeasured = 0;
+  for (const d of recs) {
+    const measured = recordIsMeasured(d);
+    if (measured) recorded = true; else unmeasured++;
+    const model = String(d.model ?? "sonnet").toLowerCase();
+    cum += priced(table, d);
+    iterations.push({
+      iteration: d.iteration ?? null, timestamp: d.timestamp ?? null, model: d.model ? model : null, phase: d.phase ?? "unknown", provider: d.provider ?? null,
+      input_tokens: measured ? num0(d.input_tokens) : null, output_tokens: measured ? num0(d.output_tokens) : null,
+      cost_usd: measured ? r6(priced(table, d)) : null, cumulative_usd: measured ? r6(cum) : null,
+    });
+  }
+  const runs: Rec[] = [];
+  let projectTotal = 0, runsMeasured = 0;
+  const proofs = join(lokiDir, "proofs");
+  let entries: string[] = [];
+  try { entries = readdirSync(proofs).sort(); } catch { /* none */ }
+  for (const e of entries) {
+    try { if (!statSync(join(proofs, e)).isDirectory()) continue; } catch { continue; }
+    const p = readJson(join(proofs, e, "proof.json"));
+    if (!isObj(p)) continue;
+    const cost = isObj(p.cost) ? p.cost : {};
+    const usd = isNum(cost.usd) ? cost.usd : null;
+    if (usd !== null) { projectTotal += usd; runsMeasured++; }
+    runs.push({
+      run_id: p.run_id ?? e, generated_at: p.generated_at ?? null, model: isObj(p.provider) ? (p.provider.model ?? null) : null,
+      cost_usd: usd !== null ? r6(usd) : null, cost_partial: cost.cost_partial === true,
+      files_changed: isObj(p.files_changed) ? (p.files_changed.count ?? null) : null, final_verdict: isObj(p.council) ? (p.council.final_verdict ?? null) : null,
+    });
+  }
+  runs.sort((a, b) => String(b.generated_at ?? "").localeCompare(String(a.generated_at ?? "")));
+  return {
+    current_run: { iterations, total_usd: recorded ? r6(cum) : null, cost_recorded: recorded, partial: recorded && unmeasured > 0, unmeasured_iterations: unmeasured },
+    runs, runs_count: runs.length,
+    project_total_usd: runsMeasured ? r6(projectTotal) : null, project_total_partial: runsMeasured > 0 && runsMeasured < runs.length,
+    budget: budgetSnapshot(lokiDir),
+    ...(recorded || runsMeasured ? {} : { not_measured: NOT_MEASURED }),
+  };
+}
+
+export const lokiDirOf = (repoDir: string) => join(repoDir, ".loki");
+export const lokiDirExists = (repoDir: string) => existsSync(lokiDirOf(repoDir));
+
+export function mount(ctx: RouteCtx): void {
+  // Disk-reading routes: with a token the bearer (tokenGuard) is the gate; without one they are loopback-only, like the probe routes.
+  const deny = { error: "loopback only without a token" };
+  ctx.app.get("/v1/cost/snapshot", (c) => (probeAllowed(ctx, c) ? c.json(costSnapshot(lokiDirOf(ctx.repoDir))) : c.json(deny, 403)));
+  ctx.app.get("/v1/cost/timeline", (c) => (probeAllowed(ctx, c) ? c.json(costTimeline(lokiDirOf(ctx.repoDir))) : c.json(deny, 403)));
+}

package/packages/control-plane/src/server/routes/fleet.ts

@@ -0,0 +1,101 @@
+// CPE24-P1: fleet spend, ported from dashboard/registry.py (get_fleet_runs / get_fleet_summary). Same sources: the machine registry
+// ~/.loki/dashboard/projects.json plus each project's .loki/ (dashboard-state.json, session.json, metrics/efficiency/*.json, context/tracking.json).
+// A run with no measured cost has cost_usd null; the summed total is null when none measured and flagged partial when some did not.
+import { readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import { probeAllowed, type RouteCtx } from "./index.ts";
+import { NOT_MEASURED, readJson, recordIsMeasured } from "./cost_ledger.ts";
+
+type Rec = Record<string, unknown>;
+const isNum = (v: unknown): v is number => typeof v === "number" && Number.isFinite(v);
+const isObj = (v: unknown): v is Rec => typeof v === "object" && v !== null && !Array.isArray(v);
+
+export const registryFile = () => join(process.env.HOME ?? homedir(), ".loki", "dashboard", "projects.json");
+
+export function pidAlive(pid: unknown): boolean {
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return false;
+  try { process.kill(pid, 0); return true; } catch (e) { return (e as NodeJS.ErrnoException).code === "EPERM"; }
+}
+
+export function projectSnapshot(path: string) {
+  const snap = { phase: "", iteration: null as number | null, cost_usd: null as number | null, started_at: null as string | null, ended_at: null as string | null };
+  if (!path) return snap;
+  const loki = join(path, ".loki");
+  const st = readJson(join(loki, "dashboard-state.json"));
+  if (isObj(st)) { snap.phase = typeof st.phase === "string" ? st.phase : ""; snap.iteration = Number.isInteger(st.iteration) ? (st.iteration as number) : null; }
+  const ss = readJson(join(loki, "session.json"));
+  if (isObj(ss)) {
+    const a = ss.startedAt || ss.started_at, b = ss.endedAt || ss.ended_at;
+    snap.started_at = typeof a === "string" ? a : null;
+    snap.ended_at = typeof b === "string" ? b : null;
+  }
+  let cost = 0, found = false;
+  const eff = join(loki, "metrics", "efficiency");
+  let names: string[] = [];
+  try { names = readdirSync(eff).filter((n) => n.endsWith(".json")); } catch { /* none */ }
+  for (const n of names) {
+    const d = readJson(join(eff, n));
+    if (isObj(d) && isNum(d.cost_usd) && recordIsMeasured(d)) { cost += d.cost_usd; found = true; }
+  }
+  if (!found) {
+    const t = readJson(join(loki, "context", "tracking.json"));
+    const totals = isObj(t) && isObj(t.totals) ? t.totals : null;
+    if (totals && isNum(totals.total_cost_usd) && recordIsMeasured({ cost_usd: totals.total_cost_usd, input_tokens: totals.total_input, output_tokens: totals.total_output })) {
+      cost = totals.total_cost_usd; found = true;
+    }
+  }
+  snap.cost_usd = found ? Math.round(cost * 1e6) / 1e6 : null;
+  return snap;
+}
+
+export function fleetRuns(includeInactive = true, file = registryFile()) {
+  let projects: Rec[] = [];
+  try {
+    const reg = JSON.parse(readFileSync(file, "utf8"));
+    if (isObj(reg) && isObj(reg.projects)) projects = Object.values(reg.projects).filter(isObj);
+  } catch { return []; }
+  if (!includeInactive) projects = projects.filter((p) => p.status === "active");
+  const out = projects.map((p) => {
+    const path = typeof p.path === "string" ? p.path : "";
+    const running = pidAlive(p.pid);
+    const snap = projectSnapshot(path);
+    const reg = String(p.status ?? "unknown").toLowerCase();
+    const status = running ? "running" : ["running", "building", "active", "in_progress"].includes(reg) ? "stale" : (p.status ?? "unknown");
+    let duration: number | null = null;
+    if (snap.started_at) {
+      const s = Date.parse(snap.started_at);
+      if (!Number.isNaN(s)) {
+        const e = snap.ended_at && !running ? Date.parse(snap.ended_at) : NaN;
+        duration = Math.max(0, Math.floor(((Number.isNaN(e) ? Date.now() : e) - s) / 1000));
+      }
+    }
+    return {
+      id: p.id ?? null, name: (p.name as string) || (path ? basename(path) : "project"), path, status, running, phase: snap.phase,
+      iteration: snap.iteration, cost_usd: snap.cost_usd, started_at: snap.started_at, duration_seconds: duration, port: p.port ?? null,
+    };
+  });
+  out.sort((a, b) => (a.running === b.running ? String(b.started_at ?? "").localeCompare(String(a.started_at ?? "")) : a.running ? -1 : 1));
+  return out;
+}
+
+export function fleetSummary(includeInactive = true, file = registryFile()) {
+  const runs = fleetRuns(includeInactive, file);
+  const costs = runs.map((r) => r.cost_usd).filter((c): c is number => isNum(c));
+  const running = runs.filter((r) => r.running).length;
+  return {
+    total_runs: runs.length, running_runs: running, stopped_runs: runs.length - running,
+    total_cost_usd: costs.length ? Math.round(costs.reduce((a, b) => a + b, 0) * 1e6) / 1e6 : null,
+    total_cost_partial: costs.length > 0 && costs.length < runs.length,
+    ...(costs.length ? {} : { not_measured: NOT_MEASURED }),
+  };
+}
+
+export const parseInactive = (v: string | undefined) => !["false", "0", "no"].includes((v ?? "true").toLowerCase());
+
+export function mount(ctx: RouteCtx): void {
+  const deny = { error: "loopback only without a token" };
+  // /v1 never exposes a project's filesystem path.
+  ctx.app.get("/v1/fleet/runs", (c) => (probeAllowed(ctx, c) ? c.json(fleetRuns(parseInactive(c.req.query("include_inactive"))).map(({ path: _p, ...r }) => r)) : c.json(deny, 403)));
+  ctx.app.get("/v1/fleet/summary", (c) => (probeAllowed(ctx, c) ? c.json(fleetSummary(parseInactive(c.req.query("include_inactive")))) : c.json(deny, 403)));
+}

package/packages/control-plane/src/server/routes/index.ts

@@ -0,0 +1,71 @@
+// Route registry. Every planned route file has a stub module here, so later slices (CPE-04 onward) only fill their own file.
+// `app` serves everywhere; `act` is the loopback-only router (the same Hono as `app` on a loopback bind, a detached one otherwise, so its routes are never registered).
+import type { Context, Hono } from "hono";
+import type { Db } from "../../db/migrate.ts";
+import type { spawnStart } from "../spawn.ts";
+import { isLoopbackHost } from "../auth.ts";
+import { mountRepos } from "../repos.ts";
+import { mount as artifacts } from "./artifacts.ts";
+import { mount as audit } from "./audit.ts";
+import { mount as checkpoints } from "./checkpoints.ts";
+import { mount as config } from "./config.ts";
+import { mount as control } from "./control.ts";
+import { mount as cost } from "./cost.ts";
+import { mount as costLedger } from "./cost_ledger.ts";
+import { mount as fleet } from "./fleet.ts";
+import { mount as memory } from "./memory.ts";
+import { mount as metrics } from "./metrics.ts";
+import { mount as sessionControl } from "./session_control.ts";
+import { mount as integrations } from "./integrations.ts";
+import { mount as mergeRisk } from "./merge_risk.ts";
+import { mount as notify } from "./notify.ts";
+import { mount as providers } from "./providers.ts";
+import { mount as start } from "./start.ts";
+import { mount as stats } from "./stats.ts";
+import { mount as stream } from "./stream.ts";
+import { mount as verify } from "./verify.ts";
+
+export interface RouteCtx {
+  app: Hono;
+  act: Hono;
+  db: Db;
+  repoDir: string;
+  /** Bearer token when one is set (tokenGuard already enforces it on /v1/*). */
+  token?: string;
+  /** The real socket peer is loopback (not the spoofable Host header; unknown peer fails closed). */
+  peerIsLoopback: (c: Context) => boolean;
+  /** peerIsLoopback plus a loopback Host plus a JSON content type: the guard for state-changing actions. */
+  local: (c: Context) => boolean;
+  /** Binary for spawned runs (default `loki`) and a spawn seam for tests. */
+  startBin?: string;
+  spawnImpl?: typeof spawnStart;
+  /** Where BLOCKED answers are written (createApp answerDir). */
+  answerDir?: string;
+}
+
+export const routeModules: ReadonlyArray<(ctx: RouteCtx) => void> = [artifacts, stream, start, control, stats, cost, costLedger, fleet, metrics, checkpoints, memory, sessionControl, config, providers, verify, integrations, notify, audit, mergeRisk];
+
+export function registerRoutes(ctx: RouteCtx): void {
+  mountRepos(ctx.act, ctx.db, ctx.peerIsLoopback);
+  for (const m of routeModules) m(ctx);
+}
+
+/** Spawning/probing read routes: with a token set the bearer (enforced by tokenGuard) is the gate; without one they are loopback-only (peer and Host), like the act routes. */
+export function probeAllowed(ctx: Pick<RouteCtx, "token" | "peerIsLoopback">, c: Context): boolean {
+  return !!ctx.token || (ctx.peerIsLoopback(c) && isLoopbackHost(c.req.header("host")));
+}
+
+export const PROBE_CACHE_MS = 60_000;
+
+/** One cached value per key for ttlMs; concurrent callers share the in-flight promise so a burst spawns once. */
+export function ttlCache<T>(ttlMs = PROBE_CACHE_MS, now: () => number = Date.now): (key: string, load: () => Promise<T>) => Promise<T> {
+  const m = new Map<string, { at: number; p: Promise<T> }>();
+  return (key, load) => {
+    const hit = m.get(key);
+    if (hit && now() - hit.at < ttlMs) return hit.p;
+    const p = load();
+    m.set(key, { at: now(), p });
+    p.catch(() => { if (m.get(key)?.p === p) m.delete(key); });
+    return p;
+  };
+}

package/packages/control-plane/src/server/routes/integrations.ts

@@ -0,0 +1,123 @@
+// CPE-20: GET /v1/integrations. Presence-only probes: an env var NAME and a boolean, or a CLI exit code. No secret value is read into a
+// response, logged or returned. Connect is not here: the UI writes the env var NAME through PUT /v1/config (CPE-14), the only writer.
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import { parseDocument } from "yaml";
+import { resolveConfigFile } from "./config.ts";
+import { probeAllowed, ttlCache, type RouteCtx } from "./index.ts";
+
+const GH_TIMEOUT_MS = 3000;
+const isSet = (n: string | null | undefined): boolean => !!n && (process.env[n] ?? "") !== "";
+
+export type Status = "connected" | "not_connected" | "not_measured";
+export interface IntegrationRow {
+  id: string;
+  label: string;
+  status: Status;
+  /** How the status was decided: "gh_cli", "env", "mcp_file" or "none". */
+  method: string;
+  /** The env var NAME checked (never a value), or null. */
+  env_name: string | null;
+  env_set: boolean;
+  /** Dotted loki.yaml path that Connect writes, or null when loki.yaml has no slot for this service. */
+  config_path: string | null;
+  detail: string;
+}
+
+/** Exit status of `gh auth status` with output discarded; null when gh is absent, slow or fails to start. */
+export function ghAuthed(pathVar = process.env.PATH ?? "", timeoutMs = GH_TIMEOUT_MS): Promise<boolean | null> {
+  const exe = pathVar.split(delimiter).filter(Boolean).map((d) => join(d, "gh")).find((p) => existsSync(p));
+  if (!exe) return Promise.resolve(null);
+  return new Promise((resolve) => {
+    let done = false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const finish = (v: boolean | null): void => { if (!done) { done = true; clearTimeout(timer); resolve(v); } };
+    let child: ReturnType<typeof spawn>;
+    try { child = spawn(exe, ["auth", "status"], { stdio: "ignore", env: { ...process.env, NO_COLOR: "1" } }); } catch { return resolve(null); }
+    timer = setTimeout(() => { try { child.kill("SIGKILL"); } catch { /* gone */ } finish(null); }, timeoutMs);
+    child.on("error", () => finish(null));
+    child.on("close", (code) => finish(code === 0));
+  });
+}
+
+function configuredName(repoDir: string, path: string[]): string | null {
+  try {
+    const r = resolveConfigFile(repoDir);
+    if (!r.ok || !r.exists || statSync(r.file).size > 1_000_000) return null;
+    const doc = parseDocument(readFileSync(r.file, "utf8"));
+    if (doc.errors.length) return null;
+    const v = doc.getIn(path);
+    return typeof v === "string" && /^[A-Z_][A-Z0-9_]*$/.test(v) ? v : null;
+  } catch { return null; }
+}
+
+/** MCP servers declared in the repo's .mcp.json: a count only, never their env or args. */
+function mcpServers(repoDir: string): number | null {
+  try {
+    const p = join(repoDir, ".mcp.json");
+    if (!existsSync(p) || statSync(p).size > 1_000_000) return null;
+    const j = JSON.parse(readFileSync(p, "utf8")) as { mcpServers?: Record<string, unknown> };
+    return j.mcpServers && typeof j.mcpServers === "object" ? Object.keys(j.mcpServers).length : null;
+  } catch { return null; }
+}
+
+/** Services loki.yaml has no key for: only conventional env var names are checked, and Connect is not offered. */
+const CONVENTIONAL: Array<{ id: string; label: string; names: string[] }> = [
+  { id: "gitlab", label: "GitLab", names: ["GITLAB_TOKEN", "GITLAB_PRIVATE_TOKEN"] },
+  { id: "jira", label: "Jira", names: ["JIRA_API_TOKEN", "JIRA_TOKEN"] },
+  { id: "linear", label: "Linear", names: ["LINEAR_API_KEY"] },
+  { id: "sentry", label: "Sentry", names: ["SENTRY_AUTH_TOKEN"] },
+];
+
+function conv(s: { id: string; label: string; names: string[] }): IntegrationRow {
+  const hit = s.names.find((x) => isSet(x)) ?? null;
+  return {
+    id: s.id, label: s.label, status: hit ? "connected" : "not_measured", method: hit ? "env" : "none",
+    env_name: hit, env_set: !!hit, config_path: null,
+    detail: hit ? `${hit} is set in the environment` : `${s.names.join(" or ")} is not set; only presence can be probed, so this is not measured`,
+  };
+}
+
+export async function listIntegrations(repoDir: string, gh: () => Promise<boolean | null> = () => ghAuthed()): Promise<IntegrationRow[]> {
+  const rows: IntegrationRow[] = [];
+
+  const gitEnv = configuredName(repoDir, ["git", "token_env"]);
+  const ghOk = await gh();
+  const gitEnvSet = isSet(gitEnv);
+  rows.push({
+    id: "github", label: "GitHub",
+    status: gitEnvSet || ghOk === true ? "connected" : ghOk === null && !gitEnv ? "not_measured" : "not_connected",
+    method: gitEnvSet ? "env" : ghOk !== null ? "gh_cli" : "none",
+    env_name: gitEnv, env_set: gitEnvSet, config_path: "git.token_env",
+    detail: gitEnvSet ? "git.token_env is set in the environment" : ghOk === true ? "gh auth status succeeded" : ghOk === false ? "gh is installed but not authenticated" : gitEnv ? "git.token_env names a variable that is not set" : "gh not found and git.token_env is not configured",
+  });
+
+  rows.push(conv(CONVENTIONAL[0]!));
+
+  const slackEnv = configuredName(repoDir, ["notifications", "slack_webhook_env"]);
+  const slackSet = isSet(slackEnv);
+  rows.push({
+    id: "slack", label: "Slack", status: slackSet ? "connected" : "not_connected",
+    method: slackEnv ? "env" : "none", env_name: slackEnv, env_set: slackSet, config_path: "notifications.slack_webhook_env",
+    detail: !slackEnv ? "notifications.slack_webhook_env is not configured" : slackSet ? "webhook variable is set" : "webhook variable is named but not set",
+  });
+
+  rows.push(...CONVENTIONAL.slice(1).map(conv));
+
+  const n = mcpServers(repoDir);
+  rows.push({
+    id: "mcp", label: "MCP", status: n === null ? "not_measured" : n > 0 ? "connected" : "not_connected", method: n === null ? "none" : "mcp_file",
+    env_name: null, env_set: false, config_path: null,
+    detail: n === null ? "no readable .mcp.json in the repo" : `${n} server${n === 1 ? "" : "s"} declared in .mcp.json`,
+  });
+  return rows;
+}
+
+export function mount(ctx: RouteCtx): void {
+  const cached = ttlCache<Awaited<ReturnType<typeof listIntegrations>>>();
+  ctx.app.get("/v1/integrations", async (c) => {
+    if (!probeAllowed(ctx, c)) return c.json({ error: "loopback only without a token" }, 403);
+    return c.json({ integrations: await cached(ctx.repoDir, () => listIntegrations(ctx.repoDir)) });
+  });
+}