@leostera/evalkit 0.7.0 → 0.9.0

package/dist/runner.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.mts","names":["_$_evalkit_core0.JsonValue","_$_evalkit_core0.TrajectoryEvent"],"sources":["../../runner/src/errors.ts","../../core/src/identity.ts","../../core/src/dataset.ts","../../core/src/aut-events.ts","../../core/src/catalog.ts","../../core/src/matrix.ts","../../core/src/config.ts","../../core/src/index.ts","../../runner/src/local-report-store.ts","../../runner/src/datasets.ts","../../runner/src/local-report-reader.ts","../../runner/src/matrix.ts","../../runner/src/workspace.ts","../../runner/src/index.ts"],"mappings":"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"}
+{"version":3,"file":"runner.d.mts","names":["_$_evalkit_core0.JsonValue","_$_evalkit_core0.TrajectoryEvent"],"sources":["../../runner/src/errors.ts","../../core/src/identity.ts","../../core/src/dataset.ts","../../core/src/aut-events.ts","../../core/src/catalog.ts","../../core/src/matrix.ts","../../core/src/config.ts","../../core/src/usage.ts","../../core/src/index.ts","../../runner/src/local-report-store.ts","../../runner/src/datasets.ts","../../runner/src/local-report-reader.ts","../../runner/src/matrix.ts","../../runner/src/upgrade.ts","../../runner/src/workspace.ts","../../runner/src/index.ts"],"mappings":"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"}

package/dist/runner.mjs

@@ -1,2 +1,2 @@
-import { _ as CheckpointExecutionError, a as readRunSummary, b as ScoringError, c as readTrialScoring, d as trialWorkspacePath, f as staticDatasetFile, g as CancelledError, h as AutExecutionError, i as readRunManifest, l as readTrialSummary, n as runMatrix, o as readTrialEvents, p as staticDatasetFiles, r as ownerIsGone, s as readTrialManifest, t as runEval, u as localReportStore, v as DatasetError, y as ReportError } from "./src-DhromKNu.mjs";
-export { AutExecutionError, CancelledError, CheckpointExecutionError, DatasetError, ReportError, ScoringError, localReportStore, ownerIsGone, readRunManifest, readRunSummary, readTrialEvents, readTrialManifest, readTrialScoring, readTrialSummary, runEval, runMatrix, staticDatasetFile, staticDatasetFiles, trialWorkspacePath };
+import { _ as DatasetError, a as readRunEvents, c as readRunSummary, d as staticDatasetFile, f as staticDatasetFiles, g as CheckpointExecutionError, h as CancelledError, i as ownerIsGone, l as localReportStore, m as AutExecutionError, n as upgradeReports, o as readRunManifest, r as runMatrix, s as readRunScoring, t as runEval, u as runWorkspacePath, v as ReportError, y as ScoringError } from "./src-CcdLZqFk.mjs";
+export { AutExecutionError, CancelledError, CheckpointExecutionError, DatasetError, ReportError, ScoringError, localReportStore, ownerIsGone, readRunEvents, readRunManifest, readRunScoring, readRunSummary, runEval, runMatrix, runWorkspacePath, staticDatasetFile, staticDatasetFiles, upgradeReports };

package/dist/share-worker.d.mts

@@ -5,6 +5,7 @@ type R2BucketLike = {
     body: ReadableStream<Uint8Array>;
   } | null>;
   put(key: string, value: Uint8Array | string): Promise<unknown>;
+  delete(key: string): Promise<unknown>;
   list(options: {
     prefix: string;
     cursor?: string;
@@ -66,6 +67,8 @@ type CommitRow = {
 type ShareIndex = {
   hasRun(runId: string): Promise<boolean>;
   recordRun(run: SharedRun): Promise<void>;
+  /** Removes a run from listings and its commit's counts; idempotent. */
+  forgetRun(runId: string): Promise<void>;
   repos(): Promise<RepoRow[]>;
   commits(repo: string): Promise<CommitRow[]>;
   runs(repo: string, sha: string): Promise<unknown[]>;
@@ -107,9 +110,11 @@ declare function durableObjectIndex(namespace: DurableObjectNamespaceLike): Shar
 //#endregion
 //#region ../share/src/worker.d.ts
 /**
- * Bindings for a share server Worker (see `wrangler.jsonc` in this package):
- * RESULTS (R2), INDEX (SQLite Durable Object, class ShareIndex), and ASSETS
- * (static assets: the bundled dashboard, with `run_worker_first: true`).
+ * Bindings for a share server Worker: RESULTS (R2), INDEX (SQLite Durable
+ * Object, class ShareIndex), and ASSETS (static assets: the bundled
+ * dashboard). Optional `vars`: BASE_PATH serves it below a path such as
+ * `/evals`, and REPO (a key such as `github.com/acme/agents`) turns on
+ * single-repository mode. See `ShareAppOptions`.
  */
 type ShareEnv = {
   RESULTS: R2BucketLike;
@@ -117,6 +122,8 @@ type ShareEnv = {
   ASSETS: {
     fetch(request: Request): Promise<Response>;
   };
+  BASE_PATH?: string;
+  REPO?: string;
 };
 declare const _default: {
   fetch(request: Request, env: ShareEnv): Promise<Response> | Response;

package/dist/share-worker.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"share-worker.d.mts","names":[],"sources":["../../share/src/files.ts","../../share/src/upload.ts","../../share/src/index-db.ts","../../share/src/index-do.ts","../../share/src/worker.ts"],"mappings":";;KASY;EACV,IAAI,cAAc;IAAU,MAAM,eAAe;;EACjD,IAAI,aAAa,OAAO,sBAAsB;EAC9C,KAAK;IAAW;IAAgB;MAAoB;IAClD;MAAW;;IACX;IACA;;;;;;KCFQ;KAEA;EACV;EACA;EACA;EACA;EACA;EACA;;;KAIU;EACV;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA,QAAQ;;EAER;;EAEA;;;;KCrBU;KAEA;EACV;EACA;EACA;EACA;EACA;EACA;;KAGU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;;;KAIU;EACV,OAAO,gBAAgB;EACvB,UAAU,KAAK,YAAY;EAC3B,SAAS,QAAQ;EACjB,QAAQ,eAAe,QAAQ;EAC/B,KAAK,cAAc,cAAc;;EAEjC,QAAQ,cAAc,cAAc;EACpC,OAAO,eAAe;;;;;KC1CnB;EACH;IACE;MACE,KAAK,kBAAkB,QAAQ;QAAe;;;IAEhD,gBAAgB,GAAG,YAAY,IAAI;;;KAIlC;EACH,WAAW;EACX,IAAI;IAAgB,MAAM,SAAS,UAAU,QAAQ;;;;;;;;cAmB1C;mBACM;EAEjB,YAAY,OAAO;EAYb,MAAM,SAAS,UAAU,QAAQ;;;iBAezB,mBACd,WAAW,6BACV;;;;;;;;KCtDS;EACV,SAAS;EACT,OAAO,kBAAkB;EACzB;IAAU,MAAM,SAAS,UAAU,QAAQ;;;;EAI3C,MAAK,SAAU,SAAO,KAAO,WAAW,QAAQ,YAAY"}
+{"version":3,"file":"share-worker.d.mts","names":[],"sources":["../../share/src/files.ts","../../share/src/upload.ts","../../share/src/index-db.ts","../../share/src/index-do.ts","../../share/src/worker.ts"],"mappings":";;KAUY;EACV,IAAI,cAAc;IAAU,MAAM,eAAe;;EACjD,IAAI,aAAa,OAAO,sBAAsB;EAC9C,OAAO,cAAc;EACrB,KAAK;IAAW;IAAgB;MAAoB;IAClD;MAAW;;IACX;IACA;;;;;;KCEQ;KAEA;EACV;EACA;EACA;EACA;EACA;EACA;;;KAIU;EACV;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA,QAAQ;;EAER;;EAEA;;;;KC3BU;KAEA;EACV;EACA;EACA;EACA;EACA;EACA;;KAGU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;;;KAIU;EACV,OAAO,gBAAgB;EACvB,UAAU,KAAK,YAAY;;EAE3B,UAAU,gBAAgB;EAC1B,SAAS,QAAQ;EACjB,QAAQ,eAAe,QAAQ;EAC/B,KAAK,cAAc,cAAc;;EAEjC,QAAQ,cAAc,cAAc;EACpC,OAAO,eAAe;;;;;KC5CnB;EACH;IACE;MACE,KAAK,kBAAkB,QAAQ;QAAe;;;IAEhD,gBAAgB,GAAG,YAAY,IAAI;;;KAIlC;EACH,WAAW;EACX,IAAI;IAAgB,MAAM,SAAS,UAAU,QAAQ;;;;;;;;cAoB1C;mBACM;EAEjB,YAAY,OAAO;EAYb,MAAM,SAAS,UAAU,QAAQ;;;iBAezB,mBACd,WAAW,6BACV;;;;;;;;;;KCrDS;EACV,SAAS;EACT,OAAO,kBAAkB;EACzB;IAAU,MAAM,SAAS,UAAU,QAAQ;;EAC3C;EACA;;;EAIA,MAAK,SAAU,SAAO,KAAO,WAAW,QAAQ,YAAY"}

package/dist/share-worker.mjs

@@ -1,9 +1,10 @@
-import { r as createShareApp, t as ShareIndexDb } from "./index-db-vbqEGFaU.mjs";
-import { t as r2Files } from "./files-C-U0-PWW.mjs";
+import { r as createShareApp, t as ShareIndexDb } from "./index-db-BbVblaHz.mjs";
+import { t as r2Files } from "./files-DkDQs2JL.mjs";
 //#region ../share/src/index-do.ts
 const METHODS = [
 	"hasRun",
 	"recordRun",
+	"forgetRun",
 	"repos",
 	"commits",
 	"runs",
@@ -64,7 +65,9 @@ var worker_default = { fetch(request, env) {
 				const response = await asset(`/assets/${path}`);
 				return response.ok ? response : null;
 			}
-		}
+		},
+		...env.BASE_PATH ? { basePath: env.BASE_PATH } : {},
+		...env.REPO ? { repo: env.REPO } : {}
 	}).fetch(request);
 } };
 //#endregion

package/dist/share.d.mts

@@ -1,4 +1,3 @@
-import { Hono } from "hono";
 //#region ../share/src/files.d.ts
 /** Where uploaded result files live: R2 in a Worker, a directory elsewhere. */
 type ShareFiles = {
@@ -6,6 +5,7 @@ type ShareFiles = {
   put(key: string, data: Uint8Array | string): Promise<void>;
   /** Every key below `prefix`, in no particular order. */
   list(prefix: string): AsyncIterable<string>;
+  delete(key: string): Promise<void>;
 };
 /** The subset of the Workers R2 binding used here. */
 type R2BucketLike = {
@@ -13,6 +13,7 @@ type R2BucketLike = {
     body: ReadableStream<Uint8Array>;
   } | null>;
   put(key: string, value: Uint8Array | string): Promise<unknown>;
+  delete(key: string): Promise<unknown>;
   list(options: {
     prefix: string;
     cursor?: string;
@@ -76,10 +77,16 @@ type RunUpload = {
   run: SharedRun;
   runJson: Uint8Array;
   catalog?: Uint8Array;
-  /** trials.json and trials/** files. */
+  /** detail.json and the run's other snapshot files. */
   files: BundleFile[];
 };
-export declare function parseUpload(bundle: readonly BundleFile[]): RunUpload;
+/**
+ * A run bundle's runs. A bundle from EvalKit 0.9 or later is one run; one
+ * from an older CLI (snapshot format version 1, a run of trials) is
+ * converted into one run per trial, as `POST /api/v1/upgrade` converts
+ * stored runs (RFD0008).
+ */
+export declare function parseUpload(bundle: readonly BundleFile[]): RunUpload[];
 //#endregion
 //#region ../share/src/index-db.d.ts
 /**
@@ -116,6 +123,8 @@ type CommitRow = {
 type ShareIndex = {
   hasRun(runId: string): Promise<boolean>;
   recordRun(run: SharedRun): Promise<void>;
+  /** Removes a run from listings and its commit's counts; idempotent. */
+  forgetRun(runId: string): Promise<void>;
   repos(): Promise<RepoRow[]>;
   commits(repo: string): Promise<CommitRow[]>;
   runs(repo: string, sha: string): Promise<unknown[]>;
@@ -130,6 +139,7 @@ export declare class ShareIndexDb {
   hasRun(runId: string): boolean;
   /** Idempotent: recording an indexed run again changes nothing. */
   recordRun(run: SharedRun): void;
+  forgetRun(runId: string): void;
   repos(): RepoRow[];
   commits(repo: string): CommitRow[];
   runs(repo: string, sha: string): unknown[];
@@ -162,6 +172,11 @@ type ShareEvent = {
   event: 'share.reindex';
   runs: number;
   indexed: number;
+} | {
+  event: 'share.upgrade';
+  upgraded: number;
+  runs: number;
+  remaining: number;
 } | {
   event: 'share.error';
   method: string;
@@ -176,13 +191,28 @@ type ShareAppOptions = {
   maxBundleBytes?: number;
   /** Defaults to one JSON line per event on stdout (Workers Logs indexes these). */
   log?: (event: ShareEvent) => void;
+  /**
+   * Serve everything below this path, e.g. `/evals` on a site's own domain.
+   * Every URL the server makes carries it; other paths are not answered.
+   */
+  basePath?: string;
+  /**
+   * Single-repository mode: show and accept only this repository key (as
+   * `evalkit share` derives it, e.g. `github.com/acme/agents`). Pages drop
+   * the repository from their URLs (`/-/<sha>/runs`), there is no list of
+   * repositories, and uploads for any other repository are rejected.
+   */
+  repo?: string;
 };
+/** `''` or `/a/b`: a path prefix with no trailing slash. */
+export declare function normalizeBasePath(basePath: string | undefined): string;
 /**
  * The share server: a small JSON API plus the dashboard app. It stores
  * uploaded run bundles and shows one read-only snapshot per repository commit.
  *
  *   POST /api/v1/uploads                         one run bundle
  *   POST /api/v1/reindex                         rebuild the index from stored run.json files
+ *   POST /api/v1/upgrade                         convert stored runs from before 0.9 (RFD0008)
  *   GET  /api/v1/repos                           indexed repositories
  *   GET  /api/v1/repos/<repo>/-/commits          commits, newest first
  *   GET  /api/v1/repos/<repo>/-/<sha>/data/…     snapshot data
@@ -191,9 +221,12 @@ type ShareAppOptions = {
  *   GET  /<repo>/-/<ref|prefix>/…                → full SHA
  *   GET  everything else                         the dashboard app
  *
+ * All of it below `basePath` when set. With `repo` (single-repository mode)
+ * pages are `/` (→ latest commit) and `/-/<ref|prefix>/…`.
+ *
  * There is no authentication: run it on a private network.
  */
-export declare function createShareApp(options: ShareAppOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export declare function createShareApp(options: ShareAppOptions): import("hono/hono-base").HonoBase<import("hono/types").BlankEnv, import("hono/types").BlankSchema, string, string>;
 //#endregion
 //#region ../share/src/fs-files.d.ts
 /** Result files in a directory, for `evalkit share serve` and tests. */
@@ -213,6 +246,12 @@ type ShareContext = {
   /** This commit's snapshot data (replaces `<base>/data/`). */
   data?: string;
   repo?: string;
+  /** Where this repository's pages live (`/<repo>`, or `/` in single-repository mode); a commit is `<pages>/-/<sha>/`. */
+  pages?: string;
+  /** The server's front page, below its base path. */
+  home?: string;
+  /** Single-repository mode: there is no list of repositories. */
+  single?: boolean;
   /** A ref or SHA with no shared results. */
   missing?: string;
 };
@@ -237,12 +276,15 @@ export declare function directoryAssets(root: string): DashboardAssets;
 export declare function createDirectoryShareApp(options: {
   dir: string;
   dashboardRoot: string;
-}): Promise<import("hono").Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">>;
+  basePath?: string;
+  repo?: string;
+}): Promise<import("hono/hono-base").HonoBase<import("hono/types").BlankEnv, import("hono/types").BlankSchema, string, string>>;
 //#endregion
 //#region ../share/src/paths.d.ts
 /**
- * The only files a run bundle may contain (the snapshot format from
- * `evalkit build`, for one run). Never evaluator workspaces.
+ * The only files a run bundle may contain (snapshot format version 2, from
+ * `evalkit build`, for one run): its JSON, candidate workspace files and
+ * attachments. Never evaluator workspaces.
  */
 export declare function allowedRunPath(path: string): boolean;
 /**

package/dist/share.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"share.d.mts","names":[],"sources":["../../share/src/files.ts","../../share/src/bundle.ts","../../share/src/upload.ts","../../share/src/index-db.ts","../../share/src/app.ts","../../share/src/fs-files.ts","../../share/src/html.ts","../../share/src/index-sqlite.ts","../../share/src/node.ts","../../share/src/paths.ts"],"mappings":";;;KACY;EACV,IAAI,cAAc,QAAQ,eAAe,cAAc;EACvD,IAAI,aAAa,MAAM,sBAAsB;;EAE7C,KAAK,iBAAiB;;;KAIZ;EACV,IAAI,cAAc;IAAU,MAAM,eAAe;;EACjD,IAAI,aAAa,OAAO,sBAAsB;EAC9C,KAAK;IAAW;IAAgB;MAAoB;IAClD;MAAW;;IACX;IACA;;;wBAIY,QAAQ,QAAQ,eAAe;;;;;;;;;;;qBCXlC;KAGD;EAAe;EAAc,MAAM;;wBAUzB,aAAa,OAAO,eAAe,QAAQ;;wBA2B3C,aACpB,MAAM,YACN;EAAU;IACT,QAAQ;;;;KCtCC;KAEA;EACV;EACA;EACA;EACA;EACA;EACA;;;KAIU;EACV;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA,QAAQ;;EAER;;EAEA;;;KAUU;EACV,KAAK;EACL,SAAS;EACT,UAAU;;EAEV,OAAO;;wBAGO,YAAY,iBAAiB,eAAe;;;;;;;;;;KC5ChD;EACV,IAAI,GAAG,kBAAkB,QAAQ,aAAa;EAC9C,IAAI,kBAAkB,QAAQ;EAC9B,YAAY,GAAG,YAAY,IAAI;;KAErB;KAEA;EACV;EACA;EACA;EACA;EACA;EACA;;KAGU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;;;KAIU;EACV,OAAO,gBAAgB;EACvB,UAAU,KAAK,YAAY;EAC3B,SAAS,QAAQ;EACjB,QAAQ,eAAe,QAAQ;EAC/B,KAAK,cAAc,cAAc;;EAEjC,QAAQ,cAAc,cAAc;EACpC,OAAO,eAAe;;qBA4CX;mBAEQ;mBACA;EAFnB,YACmB,KAAK,KACL,YAAW;EAK9B,OAAO;;EAKP,UAAU,KAAK;EAwDf,SAAS;EAST,QAAQ,eAAe;EAevB,KAAK,cAAc;EAUnB,QAAQ,cAAc;EAiBtB,OAAO;;;wBASO,WAAW,IAAI,eAAe;;;;KCzMlC;EACV,SAAS;EACT,IAAI,eAAe,QAAQ;;;KAIjB;EAEN;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EAAuB;EAAqB;;EAC5C;EAAwB;EAAc;;EACtC;EAAsB;EAAgB;EAAc;;KAE9C;EACV,OAAO;EACP,OAAO;EACP,QAAQ;;EAER;;EAEA,OAAO,OAAO;;;;;;;;;;;;;;;;;;wBAiCA,eAAe,SAAS,kBAAe,0BAAA,+BAAA;;;;wBCxEvC,eAAe,eAAe;;;;;;;;KCAlC;;EAEV;;EAEA;;EAEA;EACA;;EAEA;;wBAGc,eACd,cACA;EAAW;EAAc;EAAiB,QAAQ;;;;;;;;;wBCL9B,YAAY,eAAe,QAAQ;;;;wBCAzC,gBAAgB,eAAe;;wBAsBzB,wBAAwB;EAC5C;EACA;IACD,uBAAA,0BAAA,+BAAA;;;;;;;wBCfe,eAAe;;;;;wBAef,QAAQ;EAAU;EAAc;;wBAIhC,aAAa"}
+{"version":3,"file":"share.d.mts","names":[],"sources":["../../share/src/files.ts","../../share/src/bundle.ts","../../share/src/upload.ts","../../share/src/index-db.ts","../../share/src/app.ts","../../share/src/fs-files.ts","../../share/src/html.ts","../../share/src/index-sqlite.ts","../../share/src/node.ts","../../share/src/paths.ts"],"mappings":";;KACY;EACV,IAAI,cAAc,QAAQ,eAAe,cAAc;EACvD,IAAI,aAAa,MAAM,sBAAsB;;EAE7C,KAAK,iBAAiB;EACtB,OAAO,cAAc;;;KAIX;EACV,IAAI,cAAc;IAAU,MAAM,eAAe;;EACjD,IAAI,aAAa,OAAO,sBAAsB;EAC9C,OAAO,cAAc;EACrB,KAAK;IAAW;IAAgB;MAAoB;IAClD;MAAW;;IACX;IACA;;;wBAIY,QAAQ,QAAQ,eAAe;;;;;;;;;;;qBCblC;KAGD;EAAe;EAAc,MAAM;;wBAUzB,aAAa,OAAO,eAAe,QAAQ;;wBA2B3C,aACpB,MAAM,YACN;EAAU;IACT,QAAQ;;;;KChCC;KAEA;EACV;EACA;EACA;EACA;EACA;EACA;;;KAIU;EACV;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA,QAAQ;;EAER;;EAEA;;;KAUU;EACV,KAAK;EACL,SAAS;EACT,UAAU;;EAEV,OAAO;;;;;;;;wBASO,YAAY,iBAAiB,eAAe;;;;;;;;;;KCxDhD;EACV,IAAI,GAAG,kBAAkB,QAAQ,aAAa;EAC9C,IAAI,kBAAkB,QAAQ;EAC9B,YAAY,GAAG,YAAY,IAAI;;KAErB;KAEA;EACV;EACA;EACA;EACA;EACA;EACA;;KAGU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;;;KAIU;EACV,OAAO,gBAAgB;EACvB,UAAU,KAAK,YAAY;;EAE3B,UAAU,gBAAgB;EAC1B,SAAS,QAAQ;EACjB,QAAQ,eAAe,QAAQ;EAC/B,KAAK,cAAc,cAAc;;EAEjC,QAAQ,cAAc,cAAc;EACpC,OAAO,eAAe;;qBA4CX;mBAEQ;mBACA;EAFnB,YACmB,KAAK,KACL,YAAW;EAK9B,OAAO;;EAKP,UAAU,KAAK;EAwDf,UAAU;EAuBV,SAAS;EAST,QAAQ,eAAe;EAevB,KAAK,cAAc;EAUnB,QAAQ,cAAc;EAiBtB,OAAO;;;wBASO,WAAW,IAAI,eAAe;;;;KC7NlC;EACV,SAAS;EACT,IAAI,eAAe,QAAQ;;;KAIjB;EAEN;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EAAuB;EAAqB;;EAC5C;EAAwB;EAAc;;EAEtC;EACA;EACA;EACA;;EAEA;EAAsB;EAAgB;EAAc;;KAE9C;EACV,OAAO;EACP,OAAO;EACP,QAAQ;;EAER;;EAEA,OAAO,OAAO;;;;;EAKd;;;;;;;EAOA;;;wBAIc,kBAAkB;;;;;;;;;;;;;;;;;;;;;wBA2ClB,eAAe,SAAS,2CAAe,8BAAA,+BAAA;;;;wBCtGvC,eAAe,eAAe;;;;;;;;KCPlC;;EAEV;;EAEA;;EAEA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;wBAGc,eACd,cACA;EAAW;EAAc;EAAiB,QAAQ;;;;;;;;;wBCX9B,YAAY,eAAe,QAAQ;;;;wBCAzC,gBAAgB,eAAe;;wBAsBzB,wBAAwB;EAC5C;EACA;EACA;EACA;IACD,iCAAA,8BAAA,+BAAA;;;;;;;;wBCde,eAAe;;;;;wBAuBf,QAAQ;EAAU;EAAc;;wBAIhC,aAAa"}

package/dist/share.mjs

@@ -1,4 +1,4 @@
-import { a as allowedRunPath, c as dashboardIndex, d as encodeBundle, i as parseUpload, l as BUNDLE_FORMAT, n as asyncIndex, o as repoKey, r as createShareApp, s as validRepoKey, t as ShareIndexDb, u as decodeBundle } from "./index-db-vbqEGFaU.mjs";
-import { t as r2Files } from "./files-C-U0-PWW.mjs";
-import { i as directoryFiles, n as directoryAssets, r as sqliteIndex, t as createDirectoryShareApp } from "./src-CZnDXP1K.mjs";
-export { BUNDLE_FORMAT, ShareIndexDb, allowedRunPath, asyncIndex, createDirectoryShareApp, createShareApp, dashboardIndex, decodeBundle, directoryAssets, directoryFiles, encodeBundle, parseUpload, r2Files, repoKey, sqliteIndex, validRepoKey };
+import { a as parseUpload, c as validRepoKey, d as decodeBundle, f as encodeBundle, i as normalizeBasePath, l as dashboardIndex, n as asyncIndex, o as allowedRunPath, r as createShareApp, s as repoKey, t as ShareIndexDb, u as BUNDLE_FORMAT } from "./index-db-BbVblaHz.mjs";
+import { t as r2Files } from "./files-DkDQs2JL.mjs";
+import { i as directoryFiles, n as directoryAssets, r as sqliteIndex, t as createDirectoryShareApp } from "./src-Bn6fnZnF.mjs";
+export { BUNDLE_FORMAT, ShareIndexDb, allowedRunPath, asyncIndex, createDirectoryShareApp, createShareApp, dashboardIndex, decodeBundle, directoryAssets, directoryFiles, encodeBundle, normalizeBasePath, parseUpload, r2Files, repoKey, sqliteIndex, validRepoKey };

package/dist/skills/evalkit/SKILL.md

@@ -12,7 +12,7 @@ This is a Bun workspace whose `new` CLI command generates standalone projects. `
 Each sibling directory is a separately discoverable skill. Read its `SKILL.md` when relevant (resolve paths relative to this skill directory):
 
 - `../evalkit-agents/SKILL.md` — add or change an Agent Under Test (AUT) adapter.
-- `../evalkit-datasets/SKILL.md` — files and values for scenarios, expected answers, computed inputs, and per-trial workspaces.
+- `../evalkit-datasets/SKILL.md` — files and values for scenarios, expected answers, computed inputs, and per-run workspaces.
 - `../evalkit-evals/SKILL.md` — author scenarios: transcripts, policies, suites, and registries.
 - `../evalkit-judges/SKILL.md` — write executable predicate scorers and evaluate outcomes.
 - `../evalkit-matrices/SKILL.md` — parameter sweeps and matrix registration.
@@ -24,9 +24,9 @@ For a cross-cutting change, use all relevant subskills; for a focused task, load
 
 - Work from the eval project's directory (for the included project, `examples/starter`). By default the CLI discovers default-exported `scenarios/**/*.eval.ts` without a config or registry, and each directory directly below `scenarios/` is a suite. The starter demonstrates this zero-config discovery path; `examples/configured-matrix` demonstrates optional config and a runnable sweep. An optional `evalkit.config.js`/`.ts` customizes discovery and execution, or can supply an explicit registry/eval list. Dataset paths and `_evalkit-results` / `_evalkit-sandbox` resolve relative to the config directory or project root.
 - A scenario is one concrete conversation in its own small file. Share agents (`agents/`), judges (`judges/`) and datasets (`datasets/`) by importing them; never generate scenarios in loops or from datasets.
-- Authored suites, scenarios, datasets, agents, and matrices use stable lowercase kebab-case IDs. Only runs and trials receive generated runtime URIs.
+- Authored suites, scenarios, datasets, agents, and matrices use stable lowercase kebab-case IDs. Only runs and runs receive generated runtime URIs.
 - Keep evaluator datasets/answers private from the AUT and model unless a trusted adapter deliberately reads them and includes selected content in its prompt. Such inclusion is a deliberate treatment (for example, a memory-on condition), not a live retrieval test. Local sandboxes retain evaluator files; review reports and sandboxes before sharing.
 - Executable transcript steps are `user(...)`, `predicate(...)`, `judge(...)`, and `expectToolCall(...)`. Final scoring supports both `predicate(...)` and `judge(...)`; `judge(...)` requires a separate eval-level judge adapter. `agent(...)` transcript steps are not executable. `agentsSdk()` is unimplemented, `judgeScorer(...)` is not part of the current API, and `policy.timeoutMs` is not enforced. Verify current code/docs before proposing capabilities.
 - The built-in `piAgent()` invokes Pi with `--no-tools`, once per user message, and does not preserve conversational state. It cannot test live MCP retrieval/tool use. For that, implement a custom AUT adapter that explicitly enables the desired tools and emits observed `tool-call`/`tool-result` events; do not claim a tool was used unless the adapter records it.
-- For an intervention/A-B eval, hold task, model, and other settings constant; vary only the intervention parameter, use repeated trials and a negative control, and report exactly what was varied. A memory snapshot injected into the prompt tests memory-content usefulness, not retrieval quality. Start with a dry run and narrow smoke test; Pi-backed evaluations can incur provider costs.
+- For an intervention/A-B eval, hold task, model, and other settings constant; vary only the intervention parameter, use repeated runs and a negative control, and report exactly what was varied. A memory snapshot injected into the prompt tests memory-content usefulness, not retrieval quality. Start with a dry run and narrow smoke test; Pi-backed evaluations can incur provider costs.
 - Run `bun run check` and relevant `bun test` suites when changing code. Check `git status --short` first and preserve unrelated changes.

package/dist/skills/evalkit-agents/SKILL.md

@@ -1,16 +1,18 @@
 ---
 name: evalkit-agents
-description: Add, adapt, or debug Evalkit Agents Under Test (AUTs). Use when connecting an agent or process, implementing the session adapter, emitting events, or handling trial workspaces and runtime parameters.
+description: Add, adapt, or debug Evalkit Agents Under Test (AUTs). Use when connecting an agent or process, implementing the session adapter, emitting events, or handling run workspaces and runtime parameters.
 ---
 
 # Add an Evalkit agent
 
 Read `../evalkit/SKILL.md` for shared constraints and `../../../sites/evalkit.leostera.dev/src/content/docs/manual/agents.md`. Inspect `../../../packages/core/src/index.ts` (`AutAdapter`, `AutContext`, `AutEvent`), `../../../examples/starter/agents/greeting-agent.ts`, and `../../../packages/agents/src/index.ts` before editing.
 
-1. Identify the **Agent Under Test (AUT)**: the assistant, process, or service whose behavior the eval measures, not the scorer that grades it. Its adapter starts a fresh session per trial, receives user messages, and emits the evidence scorers inspect. Decide whether to reuse `piAgent()` for the local Pi CLI or implement `defineAgent({ identity, start })` for a different agent (`runtimes` defaults to in-process local). Do not add new agent kinds; adapt the agent with `defineAgent`. `agentsSdk()` currently throws; do not claim it is a usable remote adapter.
+1. Identify the **Agent Under Test (AUT)**: the assistant, process, or service whose behavior the eval measures, not the scorer that grades it. Its adapter starts a fresh session per run, receives user messages, and emits the evidence scorers inspect. Decide whether to reuse `piAgent()` for the local Pi CLI or implement `defineAgent({ identity, start })` for a different agent (`runtimes` defaults to in-process local). Do not add new agent kinds; adapt the agent with `defineAgent`. `agentsSdk()` currently throws; do not claim it is a usable remote adapter.
 2. Give the new agent a stable, unique lowercase kebab-case `identity.id`, meaningful `name`/`kind` and optional version. A declared runtime has `kind` and optional serializable `configuration`; the local CLI selects the first declared runtime among local/remote/sandbox, or lets an adapter without runtimes use its default. Only declare a runtime your adapter really supports.
-3. In `start({ context, runtime, onEvent })`, initialize a **new trial session**. Use `context.workspace.root` for candidate-visible data. Treat `context.evaluatorWorkspace.root` as trusted-only: never expose its path or all its contents to the AUT. `context.data[id]` holds candidate dataset values. A controlled experiment may deliberately read a specific evaluator dataset and pass only that treatment input to the model (for example, a `memory=on` arm); document that this tests injected context, not retrieval. Read and validate `context.parameters` if flags or matrix axes should affect agent behavior.
+3. In `start({ context, runtime, onEvent })`, initialize a **new run session**. Use `context.workspace.root` for candidate-visible data. Treat `context.evaluatorWorkspace.root` as trusted-only: never expose its path or all its contents to the AUT. `context.data[id]` holds candidate dataset values. A controlled experiment may deliberately read a specific evaluator dataset and pass only that treatment input to the model (for example, a `memory=on` arm); document that this tests injected context, not retrieval. Read and validate `context.parameters` if flags or matrix axes should affect agent behavior.
 4. Return a session whose `send(message)` resolves after the turn finishes and **returns the turn's result**: a reply string, or `{ reply, toolCalls: [{ name, arguments, result?, id? }], usage }`. EvalKit records it (tool calls, then the assistant message, then usage). `close()` is optional. To stream activity, call `onEvent` during the turn instead or as well; lifecycle events (`started`, `turn-started`, `turn-completed`, `completed`) are optional and `timestamp` defaults to now. Plain values are converted to JSON once; no `JSON.parse(JSON.stringify(...))` casts. Propagate failures so the runner can record them.
 5. Import the adapter from an eval; importing an agent alone does not make a run available to the CLI. Add or adapt a predicate; `output` holds the final reply. Test a single eval before a costly suite.
 
 The built-in Pi adapter starts `pi --print --no-session --no-tools` once **per message**, with no session continuity, and does not consume CLI `--model`/budget parameters. It is not suitable for evaluating live MCP/tool retrieval. For custom launch args use `piAgent({ args: [...] })`; for a tool-enabled Pi or persistent conversation, build a custom adapter, explicitly control its MCP/tool configuration, and emit real observed `tool-call`/`tool-result` events. Read and validate `context.parameters` when the model or treatment varies by matrix cell. Do not claim a memory snapshot ablation measures live memory retrieval.
+
+To keep the agent's raw log (or any file) when a passing run's sandbox is removed, call `attach(name, content)` from `start()`'s options, usually in `close()`: `await attach('logs/agent.log', log)`. Names are relative paths of `[A-Za-z0-9._-]` segments; files over 5 MB keep their end; a run's attachments are capped at 20 MB (`artifacts.attachments` in the config). Scorers have the same `attach` on their context.

package/dist/skills/evalkit-datasets/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: evalkit-datasets
-description: Add or troubleshoot EvalKit datasets and trial workspaces. Use for files and values scenarios need, expected answers kept from the agent, computed or cached inputs (onLoad/onRun), per-trial data, or dataset path failures.
+description: Add or troubleshoot EvalKit datasets and run workspaces. Use for files and values scenarios need, expected answers kept from the agent, computed or cached inputs (onLoad/onRun), per-run data, or dataset path failures.
 ---
 
 # Add EvalKit datasets
@@ -9,9 +9,9 @@ Read `../evalkit/SKILL.md` and `../../../sites/evalkit.leostera.dev/src/content/
 
 1. Define each dataset once with `defineDataset({ id, ... })` in `datasets/<name>.dataset.ts`, and import it from every scenario that uses it: `defineEval({ datasets: [a, b], ... })`. Nothing is discovered from `datasets/`. IDs are lowercase kebab-case; a scenario may use each dataset once.
 2. **Static** datasets give `files` (a directory relative to the project root, e.g. `'datasets/repo'`, or a map `{ 'path/in/workspace': 'text' | bytes | { file: 'src' } }`), `value` (any JSON-convertible value), or `valueFile` (`.json`, or `.jsonl` read as an array). Both files and a value are allowed.
-3. **Computed** datasets give `onLoad({ root, signal })` instead, returning `{ files?, value? }`. It runs once per process when a trial first needs it (never at import) and is cached; a failure is not cached. `onRun(loaded, trial)` derives each trial's copy using `trial.seed`, `trial.trialIndex` or `trial.parameters`. Put expensive or credentialed work (fetching, generating) here, not at module top level.
+3. **Computed** datasets give `onLoad({ root, signal })` instead, returning `{ files?, value? }`. It runs once per process when a run first needs it (never at import) and is cached; a failure is not cached. `onRun(loaded, run)` derives each run's copy using `run.seed`, `run.batch` or `run.parameters`. Put expensive or credentialed work (fetching, generating) here, not at module top level.
 4. Choose `visibility` deliberately. `candidate` (default): files go into the agent's workspace (`context.workspace.root`) and the value is `context.data[id]`. `evaluator`: files go into the evaluator workspace and the value is only on the scoring context. Scorers see every value as `data[id]`. Keep expected answers in evaluator datasets; never pass evaluator paths or contents to a model.
-5. Files land below `mount` (default: the dataset ID; `'.'` is the workspace root). Paths may not escape the mount; two datasets in one scenario may not write the same file. Each trial gets fresh copies.
-6. For a file-creating agent, inspect candidate files via `artifacts.candidate.root` in predicates and the report's `trials/<trial-id>/artifacts/candidate/`. Each trial records a digest per dataset; `evalkit compare` lists datasets whose digest changed.
+5. Files land below `mount` (default: the dataset ID; `'.'` is the workspace root). Paths may not escape the mount; two datasets in one scenario may not write the same file. Each run gets fresh copies.
+6. For a file-creating agent, inspect candidate files via `artifacts.candidate.root` in predicates and the report's `<run-id>/artifacts/candidate/`. Each run records a digest per dataset; `evalkit compare` lists datasets whose digest changed.
 
-Datasets never template or fan out scenarios: write one concrete scenario file per case and share the dataset. When dataset setup fails, the trial's `summary.json` and `trajectory.jsonl` record the error naming the dataset. Test the smallest scenario from the project directory.
+Datasets never template or fan out scenarios: write one concrete scenario file per case and share the dataset. When dataset setup fails, the run's `summary.json` and `trajectory.jsonl` record the error naming the dataset. Test the smallest scenario from the project directory.

package/dist/skills/evalkit-evals/SKILL.md

@@ -1,17 +1,17 @@
 ---
 name: evalkit-evals
-description: Define or modify EvalKit scenarios (evals) and suites. Use when adding prompts/transcripts, choosing datasets or scorers, configuring trial count, changing registry entries, or debugging unknown eval/suite IDs.
+description: Define or modify EvalKit scenarios (evals) and suites. Use when adding prompts/transcripts, choosing datasets or scorers, configuring run count, changing registry entries, or debugging unknown eval/suite IDs.
 ---
 
 # Add a scenario or suite
 
 Read `../evalkit/SKILL.md`, `../../../sites/evalkit.leostera.dev/src/content/docs/manual/project-structure.md` and `../../../sites/evalkit.leostera.dev/src/content/docs/manual/scoring-and-evals.md`, `../../../examples/starter/scenarios/greeting.eval.ts`, and `../../../examples/configured-matrix/evalkit.config.ts`.
 
-1. Default-export one scenario per file from `scenarios/**/*.eval.ts` using `defineEval({ id: 'my-scenario', name, agent, transcript, scoring, datasets?, policy? })`. The CLI discovers these files automatically; no registry or config is required. Choose a stable lowercase kebab-case ID. `metadata` is optional; `name` is a display label. Import shared agents, judges and datasets; keep each scenario short and concrete (a suite of a hundred cases is a hundred files), and never generate scenarios in a loop.
-2. Executable transcript steps are `user('message')`, inline `predicate(...)`, `judge(...)`, and `expectToolCall(...)`. User messages call `session.send` in order on one fresh session per trial; predicates/judges/tool-call assertions run at checkpoints. `judge(...)` requires a separate eval-level `judge` adapter. `agent(...)` transcript steps are not executable. `user(({ parameters, data, seed, trialIndex }) => ...)` computes a message per trial, so one scenario can vary its prompt by matrix axis or candidate dataset instead of being copied per variant; `policy.trials` controls independent trials (default 1, positive integer); `policy.timeoutMs` is not enforced.
+1. Default-export one scenario per file from `scenarios/**/*.eval.ts` using `defineEval({ id: 'my-scenario', name, agent, transcript, scoring, datasets?, repeat?, policy? })`. The CLI discovers these files automatically; no registry or config is required. Choose a stable lowercase kebab-case ID. `metadata` is optional; `name` is a display label. Import shared agents, judges and datasets; keep each scenario short and concrete (a suite of a hundred cases is a hundred files), and never generate scenarios in a loop.
+2. Executable transcript steps are `user('message')`, inline `predicate(...)`, `judge(...)`, and `expectToolCall(...)`. User messages call `session.send` in order on one fresh session per run; predicates/judges/tool-call assertions run at checkpoints. `judge(...)` requires a separate eval-level `judge` adapter. `agent(...)` transcript steps are not executable. `user(({ parameters, data, seed, batch }) => ...)` computes a message per run, so one scenario can vary its prompt by matrix axis or candidate dataset instead of being copied per variant; `repeat: n` starts `n` independent runs as one batch (default 1, positive integer; `--repeat` and `execution.repeat` override it); `policy.timeoutMs` is not enforced.
 3. Suites are directories: every file below `scenarios/billing/` is in suite `billing` (kebab-case directory names; deeper directories stay in the top one). Files directly in `scenarios/` have no suite; `discovery.suites: false` turns this off. Only use an explicit registry (`registry: registerEvals([defineSuite({ id, evals })])` in the config) when you need full control; it replaces discovery, and duplicate eval IDs throw.
-4. For an intervention comparison, hold task/model/prompt constant and vary one explicit matrix axis (for example `memory: ['off', 'on']`). Repeat trials and include a negative control where possible. Record whether the treatment injects a saved memory or performs live retrieval: those answer different questions. A memory dataset can be evaluator-visible to the trusted adapter, but do not expose evaluator roots or reference answers to the AUT unless revealing the chosen treatment is intentional.
-5. From the project directory run `bun run evalkit run <eval-id>`. Use `bun run evalkit run --suite <suite-id>` for a suite directory. IDs are exact human-defined strings. Inspect per-trial `scoring.json` and the run `summary.json`; completed execution is not the same as passing scores.
+4. For an intervention comparison, hold task/model/prompt constant and vary one explicit matrix axis (for example `memory: ['off', 'on']`). Repeat runs and include a negative control where possible. Record whether the treatment injects a saved memory or performs live retrieval: those answer different questions. A memory dataset can be evaluator-visible to the trusted adapter, but do not expose evaluator roots or reference answers to the AUT unless revealing the chosen treatment is intentional.
+5. From the project directory run `bun run evalkit run <eval-id>`. Use `bun run evalkit run --suite <suite-id>` for a suite directory. IDs are exact human-defined strings. Inspect per-run `scoring.json` and the run `summary.json`; completed execution is not the same as passing scores.
 6. Update relevant tests and manual/examples if changing documented behavior. Run `bun run check`, inspect a `--dry-run`, and smoke-test one narrow scenario before a potentially costly Pi-backed matrix or suite.
 
 For parameter sweeps, read `../evalkit-matrices/SKILL.md`. For scoring details, read `../evalkit-judges/SKILL.md`.

package/dist/skills/evalkit-judges/SKILL.md

@@ -3,16 +3,18 @@ name: evalkit-judges
 description: Write or debug EvalKit scoring rules and judges. Use for predicate scorers, grading trajectories/artifacts, pass/fail thresholds, partial scoring, evidence, or interpreting scorer errors.
 ---
 
-# Score EvalKit trials
+# Score EvalKit runs
 
 Read `../evalkit/SKILL.md`, `../../../sites/evalkit.leostera.dev/src/content/docs/manual/scoring-and-evals.md` and `../../../sites/evalkit.leostera.dev/src/content/docs/manual/results.md`, `../../../packages/runner/src/index.ts` (`normalizeScore`, `scoreSummary`, `runPredicate`), and `../../../examples/starter/judges/greeting.ts`.
 
 EvalKit currently executes deterministic `predicate(name, callback)` scorers and agent-backed `judge(name, { rubric })` rules. A judge rule requires a **separate eval-level `judge` adapter**; it is not inferred from or shared with the AUT. The `judgeScorer(...)` API is not implemented—do not suggest it.
 
-1. Add a named `predicate(...)` for deterministic checks or a `judge(...)` descriptor for rubric-based LLM assessment, then reference it from the eval's `scoring` array or supported transcript checkpoint. The predicate callback receives `{ context, output, data, trajectory, artifacts, checkpoints, turn? }`; `checkpoints` are earlier checkpoint results (all of them in final scoring), so a checkpoint that inspects live state before the session closes can hand its `evidence` to final scorers. Use `output` for the final assistant reply and `data[id]` for dataset values (expected answers belong in an evaluator dataset); only filter `trajectory.events` (by `source: 'aut'` and `kind`) for tool calls or intermediate messages. `context` includes per-trial IDs, metadata, random seed and optional parameters; workspace roots are absolute local paths.
+1. Add a named `predicate(...)` for deterministic checks or a `judge(...)` descriptor for rubric-based LLM assessment, then reference it from the eval's `scoring` array or supported transcript checkpoint. The predicate callback receives `{ context, output, data, trajectory, artifacts, checkpoints, turn? }`; `checkpoints` are earlier checkpoint results (all of them in final scoring), so a checkpoint that inspects live state before the session closes can hand its `evidence` to final scorers. Use `output` for the final assistant reply and `data[id]` for dataset values (expected answers belong in an evaluator dataset); only filter `trajectory.events` (by `source: 'aut'` and `kind`) for tool calls or intermediate messages. `context` includes per-run IDs, metadata, random seed and optional parameters; workspace roots are absolute local paths.
 2. A predicate returns a boolean, a finite score from 0 to 1, `{ value, passed?, explanation?, evidence? }` (evidence may be any plain value), or `skip(reason)` when the check does not apply. Without `passed`, only `value === 1` passes; give `predicate(name, fn, { passAt: 0.8 })` for a threshold. A skipped result neither passes nor fails and is left out of averages; never fake "not applicable" as a pass. Use clear evidence for debugging.
 3. A `judge(...)` rule sends a rubric plus the current turn or trajectory to the separate judge adapter, which must emit a JSON verdict. Validate that the judge is independent from the AUT, runs in an appropriate workspace, and does not receive secrets. Judge events/prompts may contain sensitive data and incur model cost; cost is not inferred unless the adapter emits usage.
 4. Normal scorers are skipped after primary execution errors unless declared with `{ supportsPartial: true }` and the required context/workspace exists. Scorer exceptions and invalid scores become recorded failures; never mask them as passes.
 5. Scorers run after the AUT closes; use `node:fs/promises` to inspect candidate/evaluator files before workspace cleanup. Keep evaluator references and secrets out of AUT events, evidence, and exported reports. Reading one evaluator dataset in a trusted adapter and deliberately injecting it as an experiment treatment is valid, but measures injected context—not whether the AUT retrieved it itself.
 6. Numbers to compare rather than gate on (tokens, time, retries, mistakes, web searches) are **metrics**, not scorers: `metric(name, (context) => number | undefined, { unit?, better? })` in the eval's `metrics` array. Never fake one as a predicate that always passes. Agent time, tokens (when the adapter reports usage) and tool calls are recorded automatically; have the adapter emit `turn-completed` usage so tokens appear. Means show on the run page and scoreboard.
-7. Test passing, failing, and missing-output trajectories; inspect `scoring.json` (`results`, `overall`, `passed`) and run `summary.json`. `overall` is an unweighted mean of valid scores, not the pass rate. Execution `status: 'completed'` can still have failed scoring; run-level `failed` is the meaningful aggregate gate.
+7. Test passing, failing, and missing-output trajectories; inspect `scoring.json` (`results`, `overall`, `passed`) and run `summary.json`. `overall` is an unweighted mean of valid scores, not the pass rate. A run whose scoring did not pass has `status: 'failed'`; `errored` means it could not finish. For repeats, count the batch's passed runs.
+
+To pass what a checkpoint saw to final scoring, return it as `evidence` and read it with `checkpoint(rule)` (pass the predicate object, not its name): `scoring: [predicate('runs', ({ checkpoint }) => checkpoint(builds)?.evidence?.stdout === 'hi')]`. Never look checkpoints up by name and cast.

package/dist/skills/evalkit-matrices/SKILL.md

@@ -9,6 +9,6 @@ Read `../evalkit/SKILL.md`, `../../../sites/evalkit.leostera.dev/src/content/doc
 
 1. In a discovery-based project, default-export each scenario from `scenarios/**/*.eval.ts` and configure `defineConfig({ matrix: { id: 'models', parameters: { model: ['a', 'b'] }, defaults? }, execution: { maxCells: 100 } })` in `evalkit.config.js`. The CLI loads the config and attaches all discovered evals. For an explicit registry instead, create `defineEvalMatrix({ id: 'models', evals: [myEval], parameters: { model: ['a', 'b'] }, defaults? })`. Axes must have JSON-serializable choices; `cells()` lazily expands eligible cells per eval. Use `cases` for correlated complete parameter assignments (e.g. language/framework pairs) and `exclude: [{ os: 'windows', arch: 'arm64' }]` for partial patterns that skip unsupported combinations; `count()` and `--dry-run` report only eligible cells.
 2. For an explicit registry, register the matrix with `registerEvals([myEval, matrix])` (or register `myEval` via a suite): a matrix **does not** register its evals for normal `run`. Do not register an eval twice outside matrices. Use eval IDs with `--eval`.
-3. In the AUT adapter read `context.parameters` and apply the values. Cells merge `defaults`, then selected axis values; `--model`, `--mode`, or `--select axis=value` **select** declared axis choices, while `--param` and budget flags override non-axis parameters. You cannot override an axis with `--param`. The built-in `piAgent()` currently ignores these parameters: using it unchanged does **not** compare different models. A constrained matrix can be run with the CLI; the dashboard lists eligible cells in bounded pages and rejects invalid one-cell submissions.
+3. In the AUT adapter read `context.parameters` and apply the values. Cells merge `defaults`, then selected axis values; `--select axis=value` (`-a`, comma-separated values allowed; `--model`/`--mode` are shorthands) **selects** declared axis choices, `-s <suite>` narrows the matrix to that suite's scenarios (`run -m models -s testing -a model=luna -a toolchain=riot`), while `--param` and budget flags override non-axis parameters. You cannot override an axis with `--param`. The built-in `piAgent()` currently ignores these parameters: using it unchanged does **not** compare different models. A constrained matrix can be run with the CLI; the dashboard lists eligible cells in bounded pages and rejects invalid one-cell submissions.
 4. Run from the eval project: `bun run evalkit run --matrix <matrix-id> --eval <eval-id> --dry-run` before dispatch; then remove `--dry-run`, optionally narrow with `--model model-a` or `--concurrency 4`. Plans exceeding `execution.maxCells` (default 100) require `--all`. `--eval` is a filter, not a matrix axis. Matrix cell keys and effective parameters are persisted in report manifests.
-5. Compare trial scores/pass counts across runs in `_evalkit-results`; verify that the AUT really applied the axis values before interpreting differences. Read `../evalkit-results/SKILL.md` for processing reports.
+5. Compare run scores/pass counts across runs in `_evalkit-results`; verify that the AUT really applied the axis values before interpreting differences. Read `../evalkit-results/SKILL.md` for processing reports.

package/dist/skills/evalkit-results/SKILL.md

@@ -1,14 +1,14 @@
 ---
 name: evalkit-results
-description: Run Evalkit locally and interpret or process evaluation results. Use for the CLI, dashboard, JSONL trajectories, trial artifacts, aggregate scores, failures, CI gates, or report retention.
+description: Run Evalkit locally and interpret or process evaluation results. Use for the CLI, dashboard, JSONL trajectories, run artifacts, aggregate scores, failures, CI gates, or report retention.
 ---
 
 # Run and process Evalkit results
 
 Read `../evalkit/SKILL.md` and `../../../sites/evalkit.leostera.dev/src/content/docs/index.md` (First run) and `../../../sites/evalkit.leostera.dev/src/content/docs/manual/cli-and-matrices.md` and `../../../sites/evalkit.leostera.dev/src/content/docs/manual/results.md`. Verify report semantics in `../../../packages/runner/src/index.ts`, `../../../packages/runner/src/local-report-store.ts`, and `../../../packages/cli/src/index.ts` before automation.
 
-1. Run from the project root containing default-exported `scenarios/**/*.eval.ts` (as in `examples/starter`, or use an optional config as in `examples/configured-matrix`), not this skill directory. Start with `bun run evalkit run <eval-id>`; run all evals only when intended (Pi-backed evals can cost tokens). `bun run evalkit run --suite <suite-id>`, `bun run evalkit run --matrix <matrix-id>`, and `bun run evalkit dev` are also available; `bun run evalkit build [--out dir]` writes a read-only static dashboard snapshot (reports plus candidate artifacts, never evaluator workspaces) that must still be reviewed before sharing; it asks to run evals first (always runs them when there are no results; `--run`/`--no-run` skip the prompt). `bun run evalkit tidy` archives runs of evals no longer in the project (marker `archived.json`, nothing deleted); archived runs are hidden in the dashboard and excluded from builds. Runs record `source` (repo, project, commit, ref, dirty) in `manifest.json`; `bun run evalkit share` uploads runs for HEAD to the configured share server (`share.url` or `EVALKIT_SHARE_URL`; `share.headers` (object or function) adds headers for an auth proxy in front of the server; `--all`, `--allow-dirty`, `--no-workspace`) and prints the URL. `bun run evalkit share serve` runs a local share server. Pass `dev --no-open` or `dev --port <n>` (`-p`) for dashboard behavior, and `--log-level debug` (on `run`, `dev` or `build`) to see the runner's structured logs. `evalkit <command> --help` lists every flag. `--concurrency` bounds cell parallelism. In CI, add `--junit <file>` (one test case per scenario and matrix cell) and gate with `bun run evalkit compare --base <branch> --fail-on regression` (or `--base-dir <results>`; `--markdown <file>` for an MR comment, `--fail-on score-drop=0.05`). `run` exits 1 on any failure or a selected file that failed to load (`--skip-broken` runs the rest), 130 when cancelled with Ctrl+C; cancelled runs are never failures. Datasets' digests are recorded per trial; `compare` lists changed datasets. For baseline/treatment studies, inspect a `--dry-run` first, keep model/task/prompt constant, and identify whether the treatment is injected context or live tool retrieval.
-2. Each `_evalkit-results/<run-uuid>/` has `manifest.json`, `summary.json`, and `trials/<trial-uuid>/{manifest.json,trajectory.jsonl,scoring.json,summary.json,artifacts/candidate/...}`. `trajectory.jsonl` contains one JSON event per line; filter by `source` and `kind`. `scoring.json` records scorer values/explanations/errors; candidate snapshot files are report artifacts.
-3. Read run `summary.json` fields `passed`, `failed`, `trialCount` for success rates. Trial `status: 'completed'` means execution finished, **not** that its scorers passed. `scoring.overall` is an unweighted mean of valid values, not a pass rate. For CI, use `jq -e '.failed == 0 and .trialCount > 0' "_evalkit-results/<run-uuid>/summary.json"` after replacing the placeholder; CLI exits nonzero when a matrix cell fails; the report supplies trial-level detail.
-4. `--json` emits one JSON object per completed matrix cell with its key, eval ID, effective parameters, and run result. Read the saved trial trajectory for adapter-emitted turn latency or token usage; EvalKit does not infer provider cost, latency, or token counts. Compare matrix conditions at both cell and trial level and avoid claiming significance from a small pilot.
-5. The dashboard can start runs and inspect events, scoring, and candidate files. `_evalkit-sandbox/<trial-uuid>/{candidate,evaluator}/` retains **both** local workspaces; evaluator secrets can live there. Treat reports and sandboxes as sensitive, apply Git ignore/retention rules, and don't share raw data without review. They may be deleted after inspection.
+1. Run from the project root containing default-exported `scenarios/**/*.eval.ts` (as in `examples/starter`, or use an optional config as in `examples/configured-matrix`), not this skill directory. Start with `bun run evalkit run <eval-id>`; run all evals only when intended (Pi-backed evals can cost tokens). `bun run evalkit run --suite <suite-id>`, `bun run evalkit run --matrix <matrix-id>`, and `bun run evalkit dev` are also available; `bun run evalkit build [--out dir]` writes a read-only static dashboard snapshot (reports plus candidate artifacts, never evaluator workspaces) that must still be reviewed before sharing; it asks to run evals first (always runs them when there are no results; `--run`/`--no-run` skip the prompt). `bun run evalkit tidy` archives runs of evals no longer in the project (marker `archived.json`, nothing deleted); archived runs are hidden in the dashboard and excluded from builds. Runs record `source` (repo, project, commit, ref, dirty) in `manifest.json`; `bun run evalkit share` uploads runs for HEAD to the configured share server (`share.url` or `EVALKIT_SHARE_URL`; `share.headers` (object or function) adds headers for an auth proxy in front of the server; `--all`, `--allow-dirty`, `--no-workspace`) and prints the URL. `bun run evalkit share serve` runs a local share server (`--base-path /evals` and `--repo <key>` match a Worker's `BASE_PATH`/`REPO` vars: below a path, one repository only). Pass `dev --no-open` or `dev --port <n>` (`-p`) for dashboard behavior, and `--log-level debug` (on `run`, `dev` or `build`) to see the runner's structured logs. `evalkit <command> --help` lists every flag. `--concurrency` bounds cell parallelism. In CI, add `--junit <file>` (one test case per scenario and matrix cell) and gate with `bun run evalkit compare --base <branch> --fail-on regression` (or `--base-dir <results>`; `--markdown <file>` for an MR comment, `--fail-on score-drop=0.05`). `run` exits 1 on any failure or a selected file that failed to load (`--skip-broken` runs the rest), 130 when cancelled with Ctrl+C; cancelled runs are never failures. Datasets' digests are recorded per run; `compare` lists changed datasets. For baseline/treatment studies, inspect a `--dry-run` first, keep model/task/prompt constant, and identify whether the treatment is injected context or live tool retrieval.
+2. Each `_evalkit-results/<run-uuid>/` is one run (one execution): `manifest.json`, `catalog.json`, `trajectory.jsonl`, `scoring.json`, `summary.json`, and `artifacts/{candidate,attachments}/`. `trajectory.jsonl` contains one JSON event per line. `repeat: n` starts `n` runs sharing `manifest.batch: { id, index, size }`. Results saved before EvalKit 0.9 (a run holding `runs/`) are skipped until `bun run evalkit upgrade` converts them; it only reads the config, so run it first when updating.
+3. A run's `summary.json` `status` is `passed`, `failed` (finished, but a score or checkpoint did not pass), `errored` (could not finish), or `cancelled` (never a failure). `scoring.overall` is an unweighted mean of valid values, not a pass rate. For a batch, count how many of its runs passed. For CI, use `jq -e '.status == "passed"' "_evalkit-results/<run-uuid>/summary.json"` after replacing the placeholder; the CLI exits nonzero when any selected run does not pass.
+4. `--json` emits one JSON object per finished run with its cell key, eval ID, effective parameters, and run result (including `batch`). Read the saved run trajectory for adapter-emitted turn latency or token usage; EvalKit does not infer provider cost, latency, or token counts. Compare matrix conditions at both cell and run level and avoid claiming significance from a small pilot.
+5. The dashboard can start runs and inspect events, scoring, and candidate files. `_evalkit-sandbox/<run-uuid>/{candidate,evaluator}/` retains **both** local workspaces; evaluator secrets can live there. Treat reports and sandboxes as sensitive, apply Git ignore/retention rules, and don't share raw data without review. They may be deleted after inspection.

package/dist/{src-CZnDXP1K.mjs → src-Bn6fnZnF.mjs}

@@ -1,5 +1,5 @@
-import { n as asyncIndex, r as createShareApp, t as ShareIndexDb } from "./index-db-vbqEGFaU.mjs";
-import { mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
+import { n as asyncIndex, r as createShareApp, t as ShareIndexDb } from "./index-db-BbVblaHz.mjs";
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve, sep } from "node:path";
 //#region ../share/src/fs-files.ts
 /** Result files in a directory, for `evalkit share serve` and tests. */
@@ -26,6 +26,9 @@ function directoryFiles(root) {
 			await writeFile(temporary, data);
 			await rename(temporary, path);
 		},
+		async delete(key) {
+			await rm(pathFor(key), { force: true });
+		},
 		async *list(prefix) {
 			const trimmed = prefix.replace(/\/+$/, "");
 			const start = trimmed ? pathFor(trimmed) : base;
@@ -127,7 +130,9 @@ async function createDirectoryShareApp(options) {
 	return createShareApp({
 		files: directoryFiles(join(options.dir, "files")),
 		index: await sqliteIndex(join(options.dir, "index.sqlite")),
-		assets: directoryAssets(options.dashboardRoot)
+		assets: directoryAssets(options.dashboardRoot),
+		...options.basePath ? { basePath: options.basePath } : {},
+		...options.repo ? { repo: options.repo } : {}
 	});
 }
 //#endregion