supipowers 1.5.2 → 2.0.0

package/src/context/savings.ts

@@ -0,0 +1,258 @@
+// src/context/savings.ts
+//
+// Pure rendering for the L1 "Savings" panel and its drilldown report. The
+// command (`/supi:context`) wires the rendered lines into the existing TUI;
+// this module never touches `ctx.ui`, never reads files, and never opens DBs
+// itself — it queries the `MetricsStore` accessors that Chunk 1 added.
+//
+// Ownership rule: the `Metrics DB: <abs-path>` footer is **not** part of any
+// function exported here. The consumer (`handleContext`) appends it once,
+// immediately after the savings lines, so no caller can produce a duplicate.
+
+import { canonicalToolName } from "../context-mode/tool-name.js";
+import type { MetricsStore } from "../context-mode/metrics-store.js";
+import { estimateTokens, formatSize } from "./analyzer.js";
+
+/** Format token counts with a k-suffix, mirroring `optimize-context.ts:13`. */
+function formatTokens(tokens: number): string {
+  if (tokens >= 1000) return `${(tokens / 1000).toFixed(1)}K`;
+  return String(tokens);
+}
+
+/** Format a millisecond delta as a coarse "Xh ago" / "Ym ago" string. */
+function relativeTime(startedAtMs: number | null, now = Date.now()): string {
+  if (startedAtMs === null) return "unknown";
+  const delta = Math.max(0, now - startedAtMs);
+  const seconds = Math.floor(delta / 1000);
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+
+const FALLBACK_LINE = "Measurement unavailable — see /supi:doctor";
+
+const FIRST_RUN_NOTICE_PREFIX = "Measurement enabled. Data lives at ";
+const FIRST_RUN_NOTICE_SUFFIX = ". Use /supi:clear to reset.";
+
+/**
+ * Single-line first-run notice. Returns `null` once the marker has been
+ * persisted, or when `store` is null (degraded mode — no marker to update).
+ */
+export function getFirstRunNotice(
+  store: MetricsStore | null,
+  projectSlug: string,
+  dbAbsPath: string,
+): string | null {
+  if (!store) return null;
+
+  let meta;
+  try {
+    meta = store.getProjectMeta(projectSlug);
+  } catch {
+    return null;
+  }
+
+  if (meta?.first_run_notice_shown_at != null) return null;
+
+  try {
+    store.setFirstRunNoticeShown(projectSlug);
+  } catch {
+    // If we can't persist, surfacing once vs forever is acceptable trade-off;
+    // failing closed (no notice) is the safer default.
+    return null;
+  }
+
+  return `${FIRST_RUN_NOTICE_PREFIX}${dbAbsPath}${FIRST_RUN_NOTICE_SUFFIX}`;
+}
+
+/** Inputs to `buildSavingsLines`. Pure data; no store handles. */
+export interface SavingsPanelInput {
+  session: { id: string; startedAt: number | null; rowCount: number };
+  totals: {
+    beforeBytes: number;
+    afterBytes: number;
+    saved: number;
+    tokensEstimated: number;
+  };
+  perCompressor: Array<{ compressor: string; saved: number; calls: number }>;
+  uniqueSourceShare: number;
+}
+
+function shortSessionId(id: string): string {
+  return id.length <= 12 ? id : `${id.slice(0, 8)}\u2026`;
+}
+
+/**
+ * Render the four savings lines for the `/supi:context` panel:
+ *   1. Session: <id> | Started: <relative> | Compressors tracked: <n>
+ *   2. Saved this session: <bytes> (~<tokens> tokens estimated)
+ *   3. Top compressors: <compressor1> -<bytes1> · <compressor2> -<bytes2> · <compressor3> -<bytes3>
+ *   4. Unique-source share: <pct>% (lower = more re-reads)
+ *
+ * The consumer is responsible for appending the `Metrics DB: <abs-path>`
+ * footer; this function deliberately does not emit it.
+ */
+export function buildSavingsLines(input: SavingsPanelInput): string[] {
+  const tracked = new Set(input.perCompressor.map((t) => t.compressor)).size;
+  const sessionLine =
+    `Session: ${shortSessionId(input.session.id)}` +
+    ` | Started: ${relativeTime(input.session.startedAt)}` +
+    ` | Compressors tracked: ${tracked}`;
+
+  const savedLine =
+    `Saved this session: ${formatSize(input.totals.saved)}` +
+    ` (~${formatTokens(input.totals.tokensEstimated)} tokens estimated)`;
+
+  let topLine: string;
+  if (input.perCompressor.length === 0) {
+    topLine = "Top compressors: (none)";
+  } else {
+    const top3 = input.perCompressor.slice(0, 3).map((t) => {
+      const display = canonicalToolName(t.compressor);
+      return `${display} -${formatSize(t.saved)}`;
+    });
+    topLine = `Top compressors: ${top3.join(" \u00b7 ")}`;
+  }
+
+  const sharePct = Math.round(input.uniqueSourceShare * 100);
+  const shareLine = `Unique-source share: ${sharePct}% (lower = more re-reads)`;
+
+  return [sessionLine, savedLine, topLine, shareLine];
+}
+
+/**
+ * Convenience renderer when the consumer has direct access to a store. When
+ * `store` is null, returns just the session line and the fallback line so the
+ * panel still surfaces *something* the user can act on. The `Metrics DB`
+ * footer is always appended by the consumer regardless of which branch fires.
+ */
+export function buildSavingsLinesFromStore(
+  store: MetricsStore | null,
+  sessionId: string,
+  sessionStartedAtMs: number | null,
+  _dbAbsPath: string,
+): string[] {
+  if (!store) {
+    const sessionLine =
+      `Session: ${shortSessionId(sessionId)}` +
+      ` | Started: ${relativeTime(sessionStartedAtMs)}` +
+      ` | Compressors tracked: 0`;
+    return [sessionLine, FALLBACK_LINE];
+  }
+
+  const totals = store.getSessionTotals(sessionId);
+  const perCompressor = store.getTopProcessors(sessionId, 5).map((entry) => ({
+    compressor: entry.processor,
+    saved: entry.saved,
+    calls: entry.calls,
+  }));
+  const uniqueSourceShare = store.getUniqueSourceShare(sessionId);
+  const tokensEstimated = estimateTokens("x".repeat(Math.max(0, totals.saved)));
+
+  return buildSavingsLines({
+    session: {
+      id: sessionId,
+      startedAt: sessionStartedAtMs,
+      rowCount: totals.rowCount,
+    },
+    totals: {
+      beforeBytes: totals.beforeBytes,
+      afterBytes: totals.afterBytes,
+      saved: totals.saved,
+      tokensEstimated,
+    },
+    perCompressor,
+    uniqueSourceShare,
+  });
+}
+
+/**
+ * Markdown drilldown for a single savings line. Reused by the
+ * `writeReport`/`openInEditor` pipeline already in `/supi:context`.
+ */
+export function formatSavingsReport(input: SavingsPanelInput): string {
+  const tracked = new Set(input.perCompressor.map((t) => t.compressor)).size;
+  const lines: string[] = [];
+  lines.push("# Session savings");
+  lines.push("");
+  lines.push(`- Session: ${input.session.id}`);
+  lines.push(`- Started: ${relativeTime(input.session.startedAt)}`);
+  lines.push(`- Rows recorded: ${input.session.rowCount}`);
+  lines.push(`- Compressors tracked: ${tracked}`);
+  lines.push("");
+
+  lines.push("## Totals");
+  lines.push("");
+  lines.push(`- Before: ${formatSize(input.totals.beforeBytes)}`);
+  lines.push(`- After: ${formatSize(input.totals.afterBytes)}`);
+  lines.push(`- Saved: ${formatSize(input.totals.saved)}`);
+  lines.push(`- Tokens estimated: ~${formatTokens(input.totals.tokensEstimated)}`);
+  lines.push("");
+
+  lines.push("## Top compressors");
+  lines.push("");
+  if (input.perCompressor.length === 0) {
+    lines.push("(no compressors tracked yet)");
+  } else {
+    for (const t of input.perCompressor) {
+      lines.push(
+        `- ${canonicalToolName(t.compressor)} — ${formatSize(t.saved)} saved across ${t.calls} call${t.calls === 1 ? "" : "s"}`,
+      );
+    }
+  }
+  lines.push("");
+
+  lines.push("## Unique-source share");
+  lines.push("");
+  const sharePct = Math.round(input.uniqueSourceShare * 100);
+  lines.push(`${sharePct}% — lower values mean the agent re-read the same source repeatedly.`);
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+/** Build a full drilldown report from the live store. Returns null when the
+ *  store is unavailable. */
+export function formatSavingsReportFromStore(
+  store: MetricsStore | null,
+  sessionId: string,
+  sessionStartedAtMs: number | null,
+): string | null {
+  if (!store) return null;
+
+  const totals = store.getSessionTotals(sessionId);
+  const perCompressor = store.getTopProcessors(sessionId, 10).map((entry) => ({
+    compressor: entry.processor,
+    saved: entry.saved,
+    calls: entry.calls,
+  }));
+  const uniqueSourceShare = store.getUniqueSourceShare(sessionId);
+  const tokensEstimated = estimateTokens("x".repeat(Math.max(0, totals.saved)));
+
+  return formatSavingsReport({
+    session: {
+      id: sessionId,
+      startedAt: sessionStartedAtMs,
+      rowCount: totals.rowCount,
+    },
+    totals: {
+      beforeBytes: totals.beforeBytes,
+      afterBytes: totals.afterBytes,
+      saved: totals.saved,
+      tokensEstimated,
+    },
+    perCompressor,
+    uniqueSourceShare,
+  });
+}
+
+/** Exported test seam so the panel test can assert exact copy. */
+export const _internals = {
+  FALLBACK_LINE,
+  FIRST_RUN_NOTICE_PREFIX,
+  FIRST_RUN_NOTICE_SUFFIX,
+};

package/src/context/startup-check.ts

@@ -0,0 +1,380 @@
+import type { ParsedSkill, PromptSection } from "./analyzer.js";
+import { parseManagedRule } from "./rule-renderer.js";
+import {
+  hashOptimizationSource,
+  type ManualOptimizationAction,
+  type RuleMode,
+} from "./startup-optimizer.js";
+import { parseManagedTokenignore } from "./tokenignore.js";
+
+export interface StartupOptimizerManifestRule {
+  path: string;
+  mode: RuleMode;
+  sourceId: string;
+  sourceName: string;
+  sourceHash: string;
+  slug: string;
+  sourceBytes: number;
+  condition?: string;
+  description?: string;
+}
+
+export interface StartupOptimizerManifest {
+  version: 1;
+  targetBytes: number;
+  sourceSetHash: string;
+  beforeBytes: number;
+  estimatedAfterBytes: number;
+  estimatedSavedBytes: number;
+  rules: StartupOptimizerManifestRule[];
+  tokenignore: {
+    path: string;
+    entries: string[];
+    hash: string;
+  };
+  manualActions: ManualOptimizationAction[];
+}
+
+export type StartupCheckStatus = "pass" | "warn" | "fail";
+
+export type StartupCheckReason =
+  | "missing-manifest"
+  | "malformed-manifest"
+  | "missing-rule"
+  | "unmanaged-rule"
+  | "malformed-rule"
+  | "rule-drift"
+  | "rule-body-drift"
+  | "tokenignore-drift"
+  | "still-loaded-source"
+  | "unresolved-manual-action"
+  | "prompt-over-target"
+  | "prompt-unavailable";
+
+export interface StartupCheckIssue {
+  severity: "fail" | "warn";
+  reason: StartupCheckReason;
+  path?: string;
+  sourceId?: string;
+  message: string;
+  remediation: string;
+}
+
+export interface StartupCheckInput {
+  manifestPath: string;
+  manifestText: string | null | undefined;
+  ruleFiles: Record<string, string | null | undefined>;
+  tokenignorePath: string;
+  tokenignoreText: string | null | undefined;
+  currentPrompt: string | null | undefined;
+  currentSkills: ParsedSkill[];
+  currentSections: PromptSection[];
+}
+
+export interface StartupCheckReport {
+  status: StartupCheckStatus;
+  issues: StartupCheckIssue[];
+  manifest: StartupOptimizerManifest | null;
+  manifestPath: string;
+  currentBytes: number | null;
+  targetBytes: number | null;
+  beforeBytes: number | null;
+  afterBytes: number | null;
+  sourceSetHash: string | null;
+}
+
+export function runStartupCheck(input: StartupCheckInput): StartupCheckReport {
+  if (input.currentPrompt == null) {
+    return {
+      status: "fail",
+      issues: [issue("prompt-unavailable", {
+        path: input.manifestPath,
+        message: "Current system prompt is unavailable, so L6 savings cannot be proven.",
+        remediation: "Run /supi:optimize-context --check inside an OMP session that exposes ctx.getSystemPrompt().",
+      })],
+      manifest: null,
+      manifestPath: input.manifestPath,
+      currentBytes: null,
+      targetBytes: null,
+      beforeBytes: null,
+      afterBytes: null,
+      sourceSetHash: null,
+    };
+  }
+
+  const currentBytes = byteLength(input.currentPrompt);
+  const manifestResult = parseStartupOptimizerManifest(input.manifestText, input.manifestPath);
+  if (typeof manifestResult === "string") {
+    const reason: StartupCheckReason = input.manifestText == null ? "missing-manifest" : "malformed-manifest";
+    return reportFromIssues(input.manifestPath, null, currentBytes, null, [issue(reason, {
+      path: input.manifestPath,
+      message: manifestResult,
+      remediation: reason === "missing-manifest"
+        ? "Run /supi:optimize-context --apply to create the startup optimizer manifest."
+        : "Remove or repair the manifest, then rerun /supi:optimize-context --apply.",
+    })]);
+  }
+
+  const manifest = manifestResult;
+  const issues: StartupCheckIssue[] = [];
+
+  for (const rule of manifest.rules) {
+    const text = input.ruleFiles[rule.path];
+    if (text == null) {
+      issues.push(issue("missing-rule", {
+        path: rule.path,
+        sourceId: rule.sourceId,
+        message: `Managed rule file is missing for ${rule.sourceId}.`,
+        remediation: "Rerun /supi:optimize-context --apply to regenerate managed rules.",
+      }));
+      continue;
+    }
+
+    const parsed = parseManagedRule(text);
+    if (parsed.status === "unmanaged") {
+      issues.push(issue("unmanaged-rule", {
+        path: rule.path,
+        sourceId: rule.sourceId,
+        message: `Rule file ${rule.path} is not managed by supipowers.`,
+        remediation: "Move the user-authored rule aside or choose a different slug before applying again.",
+      }));
+      continue;
+    }
+
+    if (parsed.status === "malformed") {
+      issues.push(issue("malformed-rule", {
+        path: rule.path,
+        sourceId: rule.sourceId,
+        message: `Managed rule ${rule.path} is malformed: ${parsed.error}.`,
+        remediation: "Rerun /supi:optimize-context --apply to rewrite the managed rule.",
+      }));
+      continue;
+    }
+
+    const metadata = parsed.metadata;
+    const frontmatterDrift = rule.mode === "ttsr"
+      ? parsed.frontmatter.condition !== rule.condition
+      : (typeof rule.description === "string" && parsed.frontmatter.description !== rule.description);
+
+    if (
+      metadata.sourceId !== rule.sourceId ||
+      metadata.sourceHash !== rule.sourceHash ||
+      metadata.slug !== rule.slug ||
+      metadata.mode !== rule.mode ||
+      metadata.sourceBytes !== rule.sourceBytes ||
+      frontmatterDrift
+    ) {
+      issues.push(issue("rule-drift", {
+        path: rule.path,
+        sourceId: rule.sourceId,
+        message: `Managed rule ${rule.path} no longer matches the startup optimizer manifest.`,
+        remediation: "Rerun /supi:optimize-context --apply to refresh managed artifacts.",
+      }));
+      continue;
+    }
+
+    // Body verification — proves the rule body still matches what was migrated,
+    // not just that the supipowers-managed header is intact.
+    const actualBodyHash = hashOptimizationSource(parsed.body);
+    const actualBodyBytes = byteLength(parsed.body);
+    if (actualBodyHash !== rule.sourceHash || actualBodyBytes !== rule.sourceBytes) {
+      issues.push(issue("rule-body-drift", {
+        path: rule.path,
+        sourceId: rule.sourceId,
+        message: `Managed rule ${rule.path} body has been modified (hash/size no longer matches the manifest).`,
+        remediation: "Rerun /supi:optimize-context --apply to rewrite the managed rule from the current prompt source.",
+      }));
+    }
+  }
+
+  const tokenignore = parseManagedTokenignore(input.tokenignoreText);
+  if (
+    tokenignore.status !== "managed" ||
+    !tokenignore.hashMatches ||
+    tokenignore.hash !== manifest.tokenignore.hash ||
+    !sameStringSet(tokenignore.entries, manifest.tokenignore.entries)
+  ) {
+    issues.push(issue("tokenignore-drift", {
+      path: input.tokenignorePath,
+      message: "Managed .tokenignore block is missing, malformed, or does not match the manifest.",
+      remediation: "Rerun /supi:optimize-context --apply to refresh the managed .tokenignore block.",
+    }));
+  }
+
+  // Skill/section presence proof obligations come from BOTH `manifest.rules`
+  // (write-rule sources expected to be disabled) and `manifest.manualActions`
+  // (tech-stack-irrelevant disables and AGENTS.md split, neither of which has a
+  // generated rule file). Without checking manualActions the previous
+  // implementation could return `pass` while required manual steps were never
+  // performed.
+  const skillSourceIdsToVerify = new Set<string>();
+  const sectionSourceIdsToVerify = new Set<string>();
+  for (const rule of manifest.rules) {
+    if (rule.sourceId.startsWith("skill:")) skillSourceIdsToVerify.add(rule.sourceId);
+    else if (rule.sourceId.startsWith("section:")) sectionSourceIdsToVerify.add(rule.sourceId);
+  }
+  for (const action of manifest.manualActions) {
+    if (action.kind !== "manual-disable") continue;
+    if (action.sourceId.startsWith("skill:")) skillSourceIdsToVerify.add(action.sourceId);
+    else if (action.sourceId.startsWith("section:")) sectionSourceIdsToVerify.add(action.sourceId);
+  }
+
+  const reportedSourceIds = new Set<string>();
+  for (const skill of input.currentSkills) {
+    const sourceId = `skill:${skill.name.trim().toLowerCase()}`;
+    if (!skillSourceIdsToVerify.has(sourceId)) continue;
+    if (reportedSourceIds.has(sourceId)) continue;
+    reportedSourceIds.add(sourceId);
+    issues.push(issue("still-loaded-source", {
+      sourceId,
+      message: `Migrated source ${sourceId} is still loaded in the startup prompt.`,
+      remediation: "Disable the original skill/source and restart OMP so the new managed rule is picked up.",
+    }));
+  }
+  for (const section of input.currentSections) {
+    const sourceId = `section:${section.label}`;
+    if (!sectionSourceIdsToVerify.has(sourceId)) continue;
+    if (reportedSourceIds.has(sourceId)) continue;
+    reportedSourceIds.add(sourceId);
+    issues.push(issue("still-loaded-source", {
+      sourceId,
+      message: `Migrated section ${sourceId} is still present in the startup prompt.`,
+      remediation: "Remove or split the section and restart OMP so the prompt actually shrinks.",
+    }));
+  }
+
+  // manual-agents-split proof: the AGENTS.md (or named) section must be at or
+  // below the threshold the planner recorded.
+  for (const action of manifest.manualActions) {
+    if (action.kind !== "manual-agents-split") continue;
+    const matching = input.currentSections.find((section) => section.label === action.sourceName);
+    if (!matching) continue;
+    if (matching.bytes > action.thresholdBytes) {
+      issues.push(issue("unresolved-manual-action", {
+        sourceId: action.sourceId,
+        message: `${action.sourceName} is still ${matching.bytes} bytes, above threshold ${action.thresholdBytes}.`,
+        remediation: action.remediation,
+      }));
+    }
+  }
+
+  if (currentBytes > manifest.targetBytes) {
+    issues.push(issue("prompt-over-target", {
+      message: `Current startup prompt is ${currentBytes} bytes, above target ${manifest.targetBytes} bytes.`,
+      remediation: "Disable migrated sources, split oversized startup files, then restart OMP before rerunning --check.",
+    }));
+  }
+
+  return reportFromIssues(input.manifestPath, manifest, currentBytes, manifest.targetBytes, issues);
+}
+
+/**
+ * Parse and validate a `manifest.json` from disk. Exported so the command and
+ * the check share one parser; previously the command had its own ad-hoc
+ * partial parser that could accept shapes the real validator would reject.
+ *
+ * Returns the validated manifest or a human-readable error string.
+ */
+export function parseStartupOptimizerManifest(
+  text: string | null | undefined,
+  manifestPath: string,
+): StartupOptimizerManifest | string {
+  if (text == null) return `Startup optimizer manifest is missing at ${manifestPath}.`;
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    return `Startup optimizer manifest is malformed: ${(error as Error).message}.`;
+  }
+
+  if (!isRecord(parsed)) return "Startup optimizer manifest must be an object.";
+  if (parsed.version !== 1) return "Startup optimizer manifest has unsupported version.";
+  if (!isFiniteNumber(parsed.targetBytes)) return "Startup optimizer manifest is missing targetBytes.";
+  if (typeof parsed.sourceSetHash !== "string") return "Startup optimizer manifest is missing sourceSetHash.";
+  if (!isFiniteNumber(parsed.beforeBytes)) return "Startup optimizer manifest is missing beforeBytes.";
+  if (!isFiniteNumber(parsed.estimatedAfterBytes)) return "Startup optimizer manifest is missing estimatedAfterBytes.";
+  if (!isFiniteNumber(parsed.estimatedSavedBytes)) return "Startup optimizer manifest is missing estimatedSavedBytes.";
+  if (!Array.isArray(parsed.rules)) return "Startup optimizer manifest is missing rules.";
+  if (!isRecord(parsed.tokenignore)) return "Startup optimizer manifest is missing tokenignore.";
+  if (!Array.isArray(parsed.manualActions)) return "Startup optimizer manifest is missing manualActions.";
+
+  const rules: StartupOptimizerManifestRule[] = [];
+  for (const candidate of parsed.rules) {
+    if (!isRecord(candidate)) return "Startup optimizer manifest has invalid rule entry.";
+    if (candidate.mode !== "ttsr" && candidate.mode !== "rulebook") return "Startup optimizer manifest has invalid rule mode.";
+    for (const key of ["path", "sourceId", "sourceName", "sourceHash", "slug"] as const) {
+      if (typeof candidate[key] !== "string") return `Startup optimizer manifest rule is missing ${key}.`;
+    }
+    if (!isFiniteNumber(candidate.sourceBytes)) return "Startup optimizer manifest rule is missing sourceBytes.";
+    rules.push(candidate as unknown as StartupOptimizerManifestRule);
+  }
+
+  if (typeof parsed.tokenignore.path !== "string") return "Startup optimizer manifest tokenignore is missing path.";
+  if (!Array.isArray(parsed.tokenignore.entries) || !parsed.tokenignore.entries.every((entry) => typeof entry === "string")) {
+    return "Startup optimizer manifest tokenignore has invalid entries.";
+  }
+  if (typeof parsed.tokenignore.hash !== "string") return "Startup optimizer manifest tokenignore is missing hash.";
+
+  return {
+    version: 1,
+    targetBytes: parsed.targetBytes,
+    sourceSetHash: parsed.sourceSetHash,
+    beforeBytes: parsed.beforeBytes,
+    estimatedAfterBytes: parsed.estimatedAfterBytes,
+    estimatedSavedBytes: parsed.estimatedSavedBytes,
+    rules,
+    tokenignore: {
+      path: parsed.tokenignore.path,
+      entries: parsed.tokenignore.entries,
+      hash: parsed.tokenignore.hash,
+    },
+    manualActions: parsed.manualActions as ManualOptimizationAction[],
+  };
+}
+
+function reportFromIssues(
+  manifestPath: string,
+  manifest: StartupOptimizerManifest | null,
+  currentBytes: number | null,
+  targetBytes: number | null,
+  issues: StartupCheckIssue[],
+): StartupCheckReport {
+  const hasFailure = issues.some((candidate) => candidate.severity === "fail");
+  const hasWarning = issues.some((candidate) => candidate.severity === "warn");
+
+  return {
+    status: hasFailure ? "fail" : hasWarning ? "warn" : "pass",
+    issues,
+    manifest,
+    manifestPath,
+    currentBytes,
+    targetBytes: targetBytes ?? manifest?.targetBytes ?? null,
+    beforeBytes: manifest?.beforeBytes ?? null,
+    afterBytes: currentBytes,
+    sourceSetHash: manifest?.sourceSetHash ?? null,
+  };
+}
+
+function issue(reason: StartupCheckReason, input: Omit<StartupCheckIssue, "severity" | "reason">): StartupCheckIssue {
+  return { severity: "fail", reason, ...input };
+}
+
+function byteLength(value: string): number {
+  return new TextEncoder().encode(value).length;
+}
+
+function isRecord(value: unknown): value is Record<string, any> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isFiniteNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function sameStringSet(a: string[], b: string[]): boolean {
+  if (a.length !== b.length) return false;
+  const left = [...a].sort();
+  const right = [...b].sort();
+  return left.every((value, index) => value === right[index]);
+}