@tangle-network/agent-eval 0.23.1 → 0.24.0

package/dist/builder-eval/index.d.ts

@@ -0,0 +1,249 @@
+import { S as SandboxDriver, H as HarnessConfig, a as SandboxHarnessResult, T as TestGradedScenario, b as TestGradedRunResult } from '../test-graded-scenario-B2kWEdh9.js';
+import { T as TraceEmitter } from '../emitter-DP_cSSiw.js';
+import { T as TraceStore, R as Run } from '../store-Db2Bv8Cf.js';
+
+/**
+ * BuilderSession — ties a builder-of-builders workflow together.
+ *
+ * Models agent-builder's shape: Project → Chat → Edit → Ship → App →
+ * AppAgent. Each layer is a Run (linked via parentRunId). The
+ * framework-enforced invariants:
+ *
+ *   - One Project → many Chats; chatId scopes runs within a project.
+ *   - One Chat = one builder Run with `layer='builder'`.
+ *   - One Ship = one child Run with `layer='app-build'` + SandboxHarness.
+ *   - One AppScenario = one grandchild Run with `layer='app-runtime'`.
+ *
+ * Consumers obtain a BuilderSession, call `startChat`, drive the
+ * builder agent (emitting spans), and call `ship` / `runAppScenario`
+ * as the workflow progresses. The session reconstructs itself from
+ * trace data via `resume(store, projectId)`.
+ */
+
+interface BuilderSessionInit {
+    projectId: string;
+    chatId?: string;
+    /** Free-form: user's task description, project name, etc. Stored on the builder Run. */
+    tags?: Record<string, string>;
+}
+interface ShipOptions {
+    harness: HarnessConfig;
+    driver?: SandboxDriver;
+    /** scenarioId of this app-build run. Defaults to `${projectId}/build`. */
+    scenarioId?: string;
+}
+interface RunAppScenarioOptions {
+    scenario: TestGradedScenario;
+    /** Harness driver override; defaults to the one the session was created with. */
+    driver?: SandboxDriver;
+}
+declare class BuilderSession {
+    private store;
+    private builderEmitter;
+    readonly projectId: string;
+    readonly chatId: string;
+    private builderRunId?;
+    private lastBuildRunId?;
+    private defaultDriver?;
+    constructor(store: TraceStore, init: BuilderSessionInit, driver?: SandboxDriver);
+    /** Start the builder (L0) run for this chat. Returns the runId. */
+    startChat(scenarioId?: string): Promise<string>;
+    /** The emitter for builder-level spans (edits, LLM calls, tool invocations). */
+    get emitter(): TraceEmitter;
+    /**
+     * Ship the project's generated app: run the sandbox harness as a child
+     * Run (`layer='app-build'`). Returns the build result + runId.
+     */
+    ship(options: ShipOptions): Promise<{
+        runId: string;
+        result: SandboxHarnessResult;
+    }>;
+    /**
+     * Run a domain scenario against the just-built app as a grandchild Run
+     * (`layer='app-runtime'`). The `ship` call must precede this so the
+     * parent is set correctly; if no build exists yet the session attaches
+     * directly to the builder run (useful for prototypes).
+     */
+    runAppScenario(options: RunAppScenarioOptions): Promise<TestGradedRunResult>;
+    /** Record an end-of-chat meta score (judge verdict on whether the builder
+     *  served the user's intent). Accepts a numeric score + optional rationale. */
+    recordMetaScore(score: number, rationale?: string): Promise<void>;
+    /** Close the builder Run with a final outcome. */
+    endChat(outcome: {
+        pass: boolean;
+        score?: number;
+        notes?: string;
+    }): Promise<void>;
+    /**
+     * Inline app-runtime run — for cases where the "scenario" isn't a
+     * SWE-bench-style test suite but a live agent interaction (LLM chat,
+     * domain flow). Returns an emitter bound to a fresh Run in the
+     * `app-runtime` layer; caller emits spans inside and calls
+     * `.endRun()` with the final verdict.
+     */
+    startAppRuntime(scenarioId: string): Promise<TraceEmitter>;
+    /**
+     * Lightweight "ship marker" — record an app-build Run with a caller-
+     * provided verdict. Use when there isn't a sandbox harness to run but
+     * you still want to mark the build state at publish time.
+     */
+    recordShipMarker(args: {
+        pass: boolean;
+        score: number;
+        scenarioId?: string;
+        notes?: string;
+    }): Promise<string>;
+    get lastBuildRunIdValue(): string | undefined;
+    get builderRunIdValue(): string | undefined;
+}
+/**
+ * Reconstruct the most recent BuilderSession state for a given project —
+ * returns { builderRunId, lastBuildRunId, chatRuns }. For chat-first UIs
+ * this is how a resumed session finds its place in the edit history.
+ */
+declare function resumeBuilderSession(store: TraceStore, projectId: string): Promise<{
+    projectId: string;
+    chatRuns: Run[];
+    lastBuilderRun?: Run;
+    lastBuildRun?: Run;
+    lastAppRuntimeRuns: Run[];
+}>;
+
+/**
+ * Three-layer evaluation — the canonical scoring breakdown for
+ * builder-of-builders workflows.
+ *
+ *   meta_score:    did the builder understand + satisfy user intent?
+ *                  (judge verdict attached to the builder run)
+ *   build_score:   did the generated scaffold build + pass its own tests?
+ *                  (outcome.score on the app-build child run)
+ *   runtime_score: did the generated agent pass its domain scenarios?
+ *                  (mean outcome.score over app-runtime grandchild runs)
+ *
+ * Returns a structured report per project. The cross-layer correlation
+ * is the highest-leverage signal the framework computes — if
+ * meta_score doesn't predict runtime_score, the builder's self-scoring
+ * is broken.
+ *
+ * Scaffold-only mode: when a project has no `app-runtime` runs (e.g. a
+ * scaffold-builder eval that grades compose + build without driving a
+ * runtime scenario), `kind` is `'scaffold-only'` and `complete` measures
+ * meta + build only. Consumers can tell the two apart without having to
+ * interpret null-runtime as either "not yet computed" or "N/A for this
+ * project shape".
+ */
+
+type ProjectKind = 'full' | 'scaffold-only';
+interface ThreeLayerProjectReport {
+    projectId: string;
+    /**
+     * `'full'` when the project has at least one `app-runtime` run;
+     * `'scaffold-only'` when it only has meta + build layers. Lets
+     * downstream consumers treat a null runtime score as expected
+     * (scaffold-only) vs. missing (full, pipeline broke).
+     */
+    kind: ProjectKind;
+    builderRunId?: string;
+    /** Judge-verdict score on the builder run (0..1 after normalization). */
+    metaScore: number | null;
+    buildRunId?: string;
+    /** 0..1 from the sandbox harness (testsPassed / testsTotal). */
+    buildScore: number | null;
+    appRuntimeRunIds: string[];
+    /** Mean of outcome.score over app-runtime runs, 0..1. Always null in scaffold-only mode. */
+    runtimeScore: number | null;
+    runtimePassRate: number | null;
+    /**
+     * Layer-aware completeness:
+     *   - `kind='full'`: all three layers scored
+     *   - `kind='scaffold-only'`: meta + build scored (runtime not applicable)
+     */
+    complete: boolean;
+}
+declare function scoreProject(store: TraceStore, projectId: string): Promise<ThreeLayerProjectReport>;
+/** Aggregate scoring across every project in a corpus. */
+declare function scoreAllProjects(store: TraceStore): Promise<ThreeLayerProjectReport[]>;
+
+/**
+ * Meta-eval correlation — the highest-leverage signal in the framework.
+ *
+ * Given a corpus of three-layer project reports, compute how well each
+ * pair of layers correlates. The question we care about most:
+ *
+ *   Does `metaScore` (what the builder thinks it did) predict
+ *   `runtimeScore` (what the user actually gets)?
+ *
+ * If r < ~0.4, the builder's self-scoring is broken — it's optimizing
+ * for something other than real-world success. If r > 0.7, meta_score
+ * is a usable proxy and can drive CI gates cheaply.
+ *
+ * Non-parametric rank correlation (Spearman) is also reported because
+ * meta scores are often ordinal-ish.
+ */
+
+interface LayerCorrelation {
+    n: number;
+    pearson: number;
+    spearman: number;
+}
+interface CorrelationReport {
+    /** Pairs present in the corpus (layers with ≥ 2 matched data points). */
+    metaVsBuild?: LayerCorrelation;
+    metaVsRuntime?: LayerCorrelation;
+    buildVsRuntime?: LayerCorrelation;
+    /** Number of complete projects (all 3 scores present). */
+    completeProjects: number;
+}
+declare function correlateLayers(reports: ThreeLayerProjectReport[]): CorrelationReport;
+
+/**
+ * ProjectRegistry — project-level aggregation over the trace corpus.
+ *
+ * Thin reader over TraceStore that answers the questions a chat-first,
+ * resumable UI needs:
+ *   - listProjects() → project IDs with latest activity
+ *   - projectTimeline(id) → chats + builds + runtime runs, chronological
+ *   - projectChats(id) → chat-level summaries (turn count, outcome)
+ *
+ * All queries are pure reads; no state duplication.
+ */
+
+interface ProjectSummary {
+    projectId: string;
+    chatCount: number;
+    buildCount: number;
+    appRuntimeCount: number;
+    lastActivityAt: number;
+    latestChatId?: string;
+    latestOutcome?: {
+        pass: boolean;
+        score?: number;
+    };
+}
+interface ChatSummary {
+    chatId: string;
+    projectId: string;
+    builderRunId: string;
+    startedAt: number;
+    endedAt?: number;
+    status: Run['status'];
+    outcome?: Run['outcome'];
+    /** Counts of spans emitted during the chat. */
+    llmTurns?: number;
+    toolCalls?: number;
+    buildRunId?: string;
+    appRuntimeRunIds: string[];
+}
+interface ProjectTimelineEntry {
+    run: Run;
+    layerBucket: 'chat' | 'build' | 'runtime' | 'other';
+}
+declare class ProjectRegistry {
+    private store;
+    constructor(store: TraceStore);
+    listProjects(): Promise<ProjectSummary[]>;
+    projectTimeline(projectId: string): Promise<ProjectTimelineEntry[]>;
+    projectChats(projectId: string): Promise<ChatSummary[]>;
+}
+
+export { BuilderSession, type BuilderSessionInit, type ChatSummary, type CorrelationReport, type LayerCorrelation, type ProjectKind, ProjectRegistry, type ProjectSummary, type ProjectTimelineEntry, type RunAppScenarioOptions, type ShipOptions, type ThreeLayerProjectReport, correlateLayers, resumeBuilderSession, scoreAllProjects, scoreProject };

package/dist/builder-eval/index.js

@@ -0,0 +1,391 @@
+import {
+  SandboxHarness,
+  runTestGradedScenario
+} from "../chunk-OWLAAMME.js";
+import {
+  judgeSpans
+} from "../chunk-47X6LRCE.js";
+import "../chunk-5BKGXME7.js";
+import {
+  TraceEmitter
+} from "../chunk-TVVP3ZZQ.js";
+import "../chunk-NG236HPC.js";
+import "../chunk-PZ5AY32C.js";
+
+// src/builder-eval/builder-session.ts
+var BuilderSession = class {
+  store;
+  builderEmitter;
+  projectId;
+  chatId;
+  builderRunId;
+  lastBuildRunId;
+  defaultDriver;
+  constructor(store, init, driver) {
+    this.store = store;
+    this.projectId = init.projectId;
+    this.chatId = init.chatId ?? cryptoId();
+    this.defaultDriver = driver;
+    this.builderEmitter = new TraceEmitter(store);
+  }
+  /** Start the builder (L0) run for this chat. Returns the runId. */
+  async startChat(scenarioId = `${this.projectId}/chat`) {
+    await this.builderEmitter.startRun({
+      scenarioId,
+      projectId: this.projectId,
+      chatId: this.chatId,
+      layer: "builder"
+    });
+    this.builderRunId = this.builderEmitter.runId;
+    return this.builderRunId;
+  }
+  /** The emitter for builder-level spans (edits, LLM calls, tool invocations). */
+  get emitter() {
+    if (!this.builderRunId) throw new Error("BuilderSession.emitter: call startChat() first");
+    return this.builderEmitter;
+  }
+  /**
+   * Ship the project's generated app: run the sandbox harness as a child
+   * Run (`layer='app-build'`). Returns the build result + runId.
+   */
+  async ship(options) {
+    if (!this.builderRunId) throw new Error("BuilderSession.ship: call startChat() first");
+    const buildEmitter = new TraceEmitter(this.store);
+    await buildEmitter.startRun({
+      scenarioId: options.scenarioId ?? `${this.projectId}/build`,
+      projectId: this.projectId,
+      chatId: this.chatId,
+      parentRunId: this.builderRunId,
+      layer: "app-build"
+    });
+    const harness = new SandboxHarness(options.driver ?? this.defaultDriver);
+    const result = await harness.run(options.harness, buildEmitter);
+    await buildEmitter.endRun({
+      pass: result.passed,
+      score: result.score,
+      failureClass: result.passed ? "success" : "sandbox_failure"
+    });
+    this.lastBuildRunId = buildEmitter.runId;
+    return { runId: buildEmitter.runId, result };
+  }
+  /**
+   * Run a domain scenario against the just-built app as a grandchild Run
+   * (`layer='app-runtime'`). The `ship` call must precede this so the
+   * parent is set correctly; if no build exists yet the session attaches
+   * directly to the builder run (useful for prototypes).
+   */
+  async runAppScenario(options) {
+    const parentRunId = this.lastBuildRunId ?? this.builderRunId;
+    if (!parentRunId)
+      throw new Error("BuilderSession.runAppScenario: call startChat() + ship() first");
+    const { scenario, driver } = options;
+    const result = await runTestGradedScenario(scenario, this.store, {
+      driver: driver ?? this.defaultDriver,
+      provenance: { codeSha: void 0, promptSha: void 0, modelFingerprint: void 0 }
+    });
+    await this.store.updateRun(result.runId, {
+      parentRunId,
+      projectId: this.projectId,
+      chatId: this.chatId,
+      layer: "app-runtime"
+    });
+    return result;
+  }
+  /** Record an end-of-chat meta score (judge verdict on whether the builder
+   *  served the user's intent). Accepts a numeric score + optional rationale. */
+  async recordMetaScore(score, rationale) {
+    if (!this.builderRunId)
+      throw new Error("BuilderSession.recordMetaScore: call startChat() first");
+    await this.builderEmitter.recordJudge({
+      judgeId: "builder-meta",
+      targetSpanId: this.builderRunId,
+      // attach to the builder run itself
+      dimension: "user_intent_satisfaction",
+      score,
+      rationale,
+      name: "builder-meta"
+    });
+  }
+  /** Close the builder Run with a final outcome. */
+  async endChat(outcome) {
+    await this.builderEmitter.endRun({
+      pass: outcome.pass,
+      score: outcome.score,
+      notes: outcome.notes
+    });
+  }
+  /**
+   * Inline app-runtime run — for cases where the "scenario" isn't a
+   * SWE-bench-style test suite but a live agent interaction (LLM chat,
+   * domain flow). Returns an emitter bound to a fresh Run in the
+   * `app-runtime` layer; caller emits spans inside and calls
+   * `.endRun()` with the final verdict.
+   */
+  async startAppRuntime(scenarioId) {
+    const parentRunId = this.lastBuildRunId ?? this.builderRunId;
+    if (!parentRunId)
+      throw new Error(
+        "BuilderSession.startAppRuntime: call startChat() + (optionally) ship() first"
+      );
+    const emitter = new TraceEmitter(this.store);
+    await emitter.startRun({
+      scenarioId,
+      projectId: this.projectId,
+      chatId: this.chatId,
+      parentRunId,
+      layer: "app-runtime"
+    });
+    return emitter;
+  }
+  /**
+   * Lightweight "ship marker" — record an app-build Run with a caller-
+   * provided verdict. Use when there isn't a sandbox harness to run but
+   * you still want to mark the build state at publish time.
+   */
+  async recordShipMarker(args) {
+    if (!this.builderRunId)
+      throw new Error("BuilderSession.recordShipMarker: call startChat() first");
+    const emitter = new TraceEmitter(this.store);
+    await emitter.startRun({
+      scenarioId: args.scenarioId ?? `${this.projectId}/ship`,
+      projectId: this.projectId,
+      chatId: this.chatId,
+      parentRunId: this.builderRunId,
+      layer: "app-build"
+    });
+    await emitter.endRun({
+      pass: args.pass,
+      score: args.score,
+      failureClass: args.pass ? "success" : "sandbox_failure",
+      notes: args.notes
+    });
+    this.lastBuildRunId = emitter.runId;
+    return emitter.runId;
+  }
+  get lastBuildRunIdValue() {
+    return this.lastBuildRunId;
+  }
+  get builderRunIdValue() {
+    return this.builderRunId;
+  }
+};
+async function resumeBuilderSession(store, projectId) {
+  const runs = await store.listRuns({ projectId });
+  const chatRuns = runs.filter((r) => r.layer === "builder").sort((a, b) => b.startedAt - a.startedAt);
+  const buildRuns = runs.filter((r) => r.layer === "app-build").sort((a, b) => b.startedAt - a.startedAt);
+  const appRuntimeRuns = runs.filter((r) => r.layer === "app-runtime").sort((a, b) => b.startedAt - a.startedAt);
+  return {
+    projectId,
+    chatRuns,
+    lastBuilderRun: chatRuns[0],
+    lastBuildRun: buildRuns[0],
+    lastAppRuntimeRuns: appRuntimeRuns
+  };
+}
+function cryptoId() {
+  if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+// src/builder-eval/correlation.ts
+function correlateLayers(reports) {
+  const completeProjects = reports.filter((r) => r.complete).length;
+  return {
+    metaVsBuild: pairwise(
+      reports,
+      (r) => r.metaScore,
+      (r) => r.buildScore
+    ),
+    metaVsRuntime: pairwise(
+      reports,
+      (r) => r.metaScore,
+      (r) => r.runtimeScore
+    ),
+    buildVsRuntime: pairwise(
+      reports,
+      (r) => r.buildScore,
+      (r) => r.runtimeScore
+    ),
+    completeProjects
+  };
+}
+function pairwise(reports, a, b) {
+  const xs = [];
+  const ys = [];
+  for (const r of reports) {
+    const x = a(r);
+    const y = b(r);
+    if (x !== null && y !== null && Number.isFinite(x) && Number.isFinite(y)) {
+      xs.push(x);
+      ys.push(y);
+    }
+  }
+  if (xs.length < 2) return void 0;
+  return {
+    n: xs.length,
+    pearson: pearsonR(xs, ys),
+    spearman: spearmanR(xs, ys)
+  };
+}
+function pearsonR(a, b) {
+  const mA = a.reduce((s, v) => s + v, 0) / a.length;
+  const mB = b.reduce((s, v) => s + v, 0) / b.length;
+  let num = 0, dA = 0, dB = 0;
+  for (let i = 0; i < a.length; i++) {
+    const da = a[i] - mA;
+    const db = b[i] - mB;
+    num += da * db;
+    dA += da * da;
+    dB += db * db;
+  }
+  if (dA === 0 || dB === 0) return dA === 0 && dB === 0 ? 1 : 0;
+  return num / Math.sqrt(dA * dB);
+}
+function spearmanR(a, b) {
+  return pearsonR(ranks(a), ranks(b));
+}
+function ranks(xs) {
+  const indexed = xs.map((v, i) => ({ v, i })).sort((x, y) => x.v - y.v);
+  const r = new Array(xs.length);
+  for (let i = 0; i < indexed.length; i++) {
+    let j = i;
+    while (j + 1 < indexed.length && indexed[j + 1].v === indexed[i].v) j++;
+    const avg = (i + j + 2) / 2;
+    for (let k = i; k <= j; k++) r[indexed[k].i] = avg;
+    i = j;
+  }
+  return r;
+}
+
+// src/builder-eval/project-registry.ts
+var ProjectRegistry = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async listProjects() {
+    const runs = await this.store.listRuns();
+    const byProject = /* @__PURE__ */ new Map();
+    for (const r of runs) {
+      if (!r.projectId) continue;
+      const arr = byProject.get(r.projectId) ?? [];
+      arr.push(r);
+      byProject.set(r.projectId, arr);
+    }
+    const summaries = [];
+    for (const [projectId, projectRuns] of byProject) {
+      const sorted = projectRuns.slice().sort((a, b) => b.startedAt - a.startedAt);
+      const chats = projectRuns.filter((r) => r.layer === "builder");
+      const builds = projectRuns.filter((r) => r.layer === "app-build");
+      const runtimes = projectRuns.filter((r) => r.layer === "app-runtime");
+      const latest = sorted[0];
+      if (!latest) continue;
+      summaries.push({
+        projectId,
+        chatCount: chats.length,
+        buildCount: builds.length,
+        appRuntimeCount: runtimes.length,
+        lastActivityAt: latest.startedAt,
+        latestChatId: chats[0]?.chatId,
+        latestOutcome: latest.outcome ? { pass: latest.outcome.pass ?? false, score: latest.outcome.score } : void 0
+      });
+    }
+    return summaries.sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+  }
+  async projectTimeline(projectId) {
+    const runs = await this.store.listRuns({ projectId });
+    const ordered = runs.slice().sort((a, b) => a.startedAt - b.startedAt);
+    return ordered.map((run) => ({
+      run,
+      layerBucket: run.layer === "builder" ? "chat" : run.layer === "app-build" ? "build" : run.layer === "app-runtime" ? "runtime" : "other"
+    }));
+  }
+  async projectChats(projectId) {
+    const builderRuns = (await this.store.listRuns({ projectId, layer: "builder" })).sort(
+      (a, b) => b.startedAt - a.startedAt
+    );
+    const childrenFor = async (runId) => this.store.listRuns({ parentRunId: runId });
+    const out = [];
+    for (const run of builderRuns) {
+      const spans = await this.store.spans({ runId: run.runId });
+      const children = await childrenFor(run.runId);
+      const build = children.find((c) => c.layer === "app-build");
+      const runtime = [];
+      if (build) {
+        const grands = await childrenFor(build.runId);
+        for (const g of grands) if (g.layer === "app-runtime") runtime.push(g.runId);
+      }
+      for (const c of children) if (c.layer === "app-runtime") runtime.push(c.runId);
+      out.push({
+        chatId: run.chatId ?? run.runId,
+        projectId,
+        builderRunId: run.runId,
+        startedAt: run.startedAt,
+        endedAt: run.endedAt,
+        status: run.status,
+        outcome: run.outcome,
+        llmTurns: spans.filter((s) => s.kind === "llm").length,
+        toolCalls: spans.filter((s) => s.kind === "tool").length,
+        buildRunId: build?.runId,
+        appRuntimeRunIds: runtime
+      });
+    }
+    return out;
+  }
+};
+
+// src/builder-eval/three-layer-eval.ts
+async function scoreProject(store, projectId) {
+  const allRuns = await store.listRuns({ projectId });
+  const builder = latestByLayer(allRuns, "builder");
+  const build = latestByLayer(allRuns, "app-build");
+  const runtime = allRuns.filter((r) => r.layer === "app-runtime");
+  const metaScore = builder ? await extractMetaScore(store, builder.runId) : null;
+  const buildScore = build?.outcome?.score ?? null;
+  const runtimeScores = runtime.map((r) => r.outcome?.score).filter((s) => typeof s === "number");
+  const runtimeScore = runtimeScores.length > 0 ? runtimeScores.reduce((a, b) => a + b, 0) / runtimeScores.length : null;
+  const runtimePassed = runtime.filter((r) => r.outcome?.pass === true).length;
+  const runtimePassRate = runtime.length > 0 ? runtimePassed / runtime.length : null;
+  const kind = runtime.length === 0 ? "scaffold-only" : "full";
+  const complete = kind === "scaffold-only" ? metaScore !== null && buildScore !== null : metaScore !== null && buildScore !== null && runtimeScore !== null;
+  return {
+    projectId,
+    kind,
+    builderRunId: builder?.runId,
+    metaScore,
+    buildRunId: build?.runId,
+    buildScore,
+    appRuntimeRunIds: runtime.map((r) => r.runId),
+    runtimeScore,
+    runtimePassRate,
+    complete
+  };
+}
+async function scoreAllProjects(store) {
+  const runs = await store.listRuns();
+  const projectIds = [...new Set(runs.map((r) => r.projectId).filter((p) => !!p))];
+  return Promise.all(projectIds.map((p) => scoreProject(store, p)));
+}
+function latestByLayer(runs, layer) {
+  const filtered = runs.filter((r) => r.layer === layer).sort((a, b) => b.startedAt - a.startedAt);
+  return filtered[0];
+}
+async function extractMetaScore(store, builderRunId) {
+  const js = await judgeSpans(store, builderRunId);
+  const meta = js.find(
+    (s) => s.judgeId === "builder-meta" && s.dimension === "user_intent_satisfaction"
+  );
+  if (!meta) return null;
+  if (meta.score >= 0 && meta.score <= 1) return meta.score;
+  if (meta.score >= 0 && meta.score <= 10) return meta.score / 10;
+  return null;
+}
+export {
+  BuilderSession,
+  ProjectRegistry,
+  correlateLayers,
+  resumeBuilderSession,
+  scoreAllProjects,
+  scoreProject
+};
+//# sourceMappingURL=index.js.map