@piagent/platform 1.2.16 → 1.3.0-ie.8

package/benchmarks/capability-v1/references/concurrent-lease-lifecycle/packages/lease/src/with-lease.js

@@ -0,0 +1,9 @@
+export async function withLease(store, key, owner, options, operation) {
+  if (!store || typeof operation !== "function" || !options) throw new TypeError("invalid lease operation");
+  if (!store.acquire(key, owner, options.now, options.ttlMs)) throw new Error("lease busy");
+  try {
+    return await operation((now) => store.renew(key, owner, now, options.ttlMs));
+  } finally {
+    store.release(key, owner);
+  }
+}

package/benchmarks/capability-v1/references/fullstack-search-contract/apps/web/src/search-view.js

@@ -0,0 +1,9 @@
+function escapeHtml(value) {
+  return String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+
+export function renderSearchResults(results) {
+  if (!Array.isArray(results)) throw new TypeError("results must be an array");
+  const items = results.map((item) => `<li data-id="${escapeHtml(item?.id ?? "")}">${escapeHtml(item?.name ?? "")}</li>`).join("");
+  return `<ul aria-label="Search results">${items}</ul>`;
+}

package/benchmarks/capability-v1/references/fullstack-search-contract/packages/shared/src/search-contract.js

@@ -0,0 +1,3 @@
+export function normalizeQuery(value) {
+  return String(value ?? "").normalize("NFD").replace(/\p{M}+/gu, "").trim().replace(/\s+/gu, " ").toLowerCase();
+}

package/benchmarks/capability-v1/references/fullstack-search-contract/services/catalog/src/search.js

@@ -0,0 +1,12 @@
+import { normalizeQuery } from "../../../packages/shared/src/search-contract.js";
+
+export function searchCatalog(items, query, options = {}) {
+  if (!options || typeof options !== "object" || Array.isArray(options)) throw new TypeError("options must be an object");
+  const limit = options.limit ?? 20;
+  if (!Array.isArray(items) || !Number.isSafeInteger(limit) || limit < 1) throw new TypeError("invalid search input");
+  const needle = normalizeQuery(query);
+  return items.filter((item) => {
+    const tags = Array.isArray(item?.tags) ? item.tags.filter((tag) => typeof tag === "string") : [];
+    return normalizeQuery([item?.name, ...tags].join(" ")).includes(needle);
+  }).slice(0, limit);
+}

package/benchmarks/capability-v1/references/multi-package-rollout/apps/admin/src/rollout-view.js

@@ -0,0 +1,6 @@
+import { normalizeRollout } from "../../../packages/policy/src/rollout.js";
+
+export function rolloutSummary(rollout) {
+  const value = normalizeRollout(rollout);
+  return `enabled=${value.enabled}; percentage=${value.percentage}; tenants=${value.tenants.join(",")}`;
+}

package/benchmarks/capability-v1/references/multi-package-rollout/packages/api/src/feature-access.js

@@ -0,0 +1,9 @@
+import { isFeatureEnabled, normalizeRollout } from "../../policy/src/rollout.js";
+
+export function featureAccess(rollout, request) {
+  const normalized = normalizeRollout(rollout);
+  if (!normalized.enabled) return { allowed: false, reason: "disabled" };
+  if (request && typeof request.tenantId === "string" && normalized.tenants.includes(request.tenantId)) return { allowed: true, reason: "tenant-override" };
+  const allowed = isFeatureEnabled(normalized, request);
+  return { allowed, reason: allowed ? "percentage" : "not-eligible" };
+}

package/benchmarks/capability-v1/references/multi-package-rollout/packages/policy/src/rollout.js

@@ -0,0 +1,29 @@
+function normalizedPercentage(value) {
+  if (!Number.isSafeInteger(value) || value < 0 || value > 100) throw new TypeError("percentage must be an integer from 0 through 100");
+  return value;
+}
+
+function normalizedTenants(value) {
+  if (!Array.isArray(value)) throw new TypeError("tenants must be an array");
+  const result = [];
+  const seen = new Set();
+  for (const tenant of value) {
+    if (typeof tenant !== "string" || !tenant.trim()) throw new TypeError("tenant must be non-empty");
+    const normalized = tenant.trim();
+    if (!seen.has(normalized)) { seen.add(normalized); result.push(normalized); }
+  }
+  return result;
+}
+
+export function normalizeRollout(input = {}) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) throw new TypeError("rollout must be an object");
+  return { enabled: Boolean(input.enabled), percentage: normalizedPercentage(input.percentage), tenants: normalizedTenants(input.tenants) };
+}
+
+export function isFeatureEnabled(rollout, subject) {
+  if (!rollout?.enabled || !subject) return false;
+  const normalized = normalizeRollout(rollout);
+  if (typeof subject.tenantId === "string" && normalized.tenants.includes(subject.tenantId)) return true;
+  if (!Number.isSafeInteger(subject.bucket) || subject.bucket < 0 || subject.bucket > 99) throw new TypeError("bucket must be an integer from 0 through 99");
+  return subject.bucket < normalized.percentage;
+}

package/benchmarks/capability-v1/references/resumable-migration-runner/packages/migration/src/plan.js

@@ -0,0 +1,32 @@
+export function migrationPlan(steps) {
+  if (!Array.isArray(steps)) throw new TypeError("steps must be an array");
+  const byId = new Map();
+  const indexById = new Map();
+  for (const [index, step] of steps.entries()) {
+    if (!step || typeof step.id !== "string" || !step.id.trim() || typeof step.apply !== "function" || byId.has(step.id) || !Array.isArray(step.dependsOn ?? [])) throw new TypeError("invalid migration step");
+    byId.set(step.id, step); indexById.set(step.id, index);
+  }
+  const remaining = new Map();
+  const dependents = new Map(steps.map((step) => [step.id, []]));
+  for (const step of steps) {
+    const dependencies = new Set(step.dependsOn ?? []);
+    for (const dependency of dependencies) {
+      if (!byId.has(dependency)) throw new TypeError("unknown dependency");
+      dependents.get(dependency).push(step.id);
+    }
+    remaining.set(step.id, dependencies.size);
+  }
+  const ready = steps.filter((step) => remaining.get(step.id) === 0).map((step) => step.id);
+  const result = [];
+  while (ready.length) {
+    ready.sort((left, right) => indexById.get(left) - indexById.get(right));
+    const id = ready.shift();
+    result.push(byId.get(id));
+    for (const dependent of dependents.get(id)) {
+      remaining.set(dependent, remaining.get(dependent) - 1);
+      if (remaining.get(dependent) === 0) ready.push(dependent);
+    }
+  }
+  if (result.length !== steps.length) throw new TypeError("migration cycle");
+  return result;
+}

package/benchmarks/capability-v1/references/resumable-migration-runner/packages/migration/src/runner.js

@@ -0,0 +1,18 @@
+import { migrationPlan } from "./plan.js";
+
+export async function runMigration({ steps, checkpoint, apply }) {
+  if (!Array.isArray(steps) || !checkpoint || typeof checkpoint.read !== "function" || typeof checkpoint.write !== "function" || typeof apply !== "function") throw new TypeError("invalid migration runner input");
+  const planned = migrationPlan(steps);
+  if (planned.some((step, index) => step.id !== steps[index].id)) throw new TypeError("steps must be in stable migration-plan order");
+  const known = new Set(steps.map((step) => step.id));
+  const stored = await checkpoint.read();
+  if (!Array.isArray(stored) || stored.some((id) => !known.has(id))) throw new TypeError("invalid migration checkpoint");
+  const completed = [...stored]; const completedSet = new Set(completed);
+  for (const step of steps) {
+    if (completedSet.has(step.id)) continue;
+    await apply(step);
+    completed.push(step.id); completedSet.add(step.id);
+    await checkpoint.write([...completed]);
+  }
+  return { completed: [...completed] };
+}

package/benchmarks/capability-v1/rubric.json

@@ -0,0 +1,60 @@
+{
+  "schemaVersion": 1,
+  "scenarios": {
+    "multi-package-rollout": [
+      { "id": "rollout-normalized-shape", "clause": "R1", "critical": true, "weight": 2 },
+      { "id": "rollout-input-immutable", "clause": "R1", "critical": true, "weight": 2 },
+      { "id": "rollout-new-object", "clause": "R1", "critical": true, "weight": 2 },
+      { "id": "rollout-invalid-object", "clause": "R2", "critical": true, "weight": 2 },
+      { "id": "rollout-invalid-percentage", "clause": "R2", "critical": true, "weight": 2 },
+      { "id": "rollout-invalid-tenants", "clause": "R2", "critical": true, "weight": 2 },
+      { "id": "rollout-tenant-override", "clause": "R3", "critical": true, "weight": 2 },
+      { "id": "rollout-percentage-boundaries", "clause": "R3", "critical": true, "weight": 2 },
+      { "id": "rollout-disabled-missing-subject", "clause": "R3", "critical": true, "weight": 2 },
+      { "id": "rollout-invalid-bucket", "clause": "R3", "critical": true, "weight": 2 },
+      { "id": "feature-access-reasons", "clause": "R4", "critical": true, "weight": 2 },
+      { "id": "rollout-summary", "clause": "R5", "critical": true, "weight": 2 },
+      { "id": "rollout-summary-validates", "clause": "R5", "critical": true, "weight": 2 }
+    ],
+    "fullstack-search-contract": [
+      { "id": "query-normalization", "clause": "S1", "critical": true, "weight": 2 },
+      { "id": "query-nullish", "clause": "S1", "critical": true, "weight": 2 },
+      { "id": "catalog-name-tag-order", "clause": "S2", "critical": true, "weight": 2 },
+      { "id": "catalog-input-immutable", "clause": "S2", "critical": true, "weight": 2 },
+      { "id": "catalog-limit-contract", "clause": "S2", "critical": true, "weight": 2 },
+      { "id": "catalog-invalid-input", "clause": "S2", "critical": true, "weight": 2 },
+      { "id": "catalog-shared-normalizer", "clause": "S2", "critical": true, "weight": 2 },
+      { "id": "search-render-exact-escaping", "clause": "S3", "critical": true, "weight": 2 },
+      { "id": "search-render-order", "clause": "S3", "critical": true, "weight": 2 },
+      { "id": "search-render-empty", "clause": "S3", "critical": true, "weight": 2 },
+      { "id": "search-render-invalid-input", "clause": "S3", "critical": true, "weight": 2 }
+    ],
+    "concurrent-lease-lifecycle": [
+      { "id": "lease-acquire-input-validation", "clause": "L1", "critical": true, "weight": 2 },
+      { "id": "lease-renew-input-validation", "clause": "L1", "critical": true, "weight": 2 },
+      { "id": "lease-release-current-input-validation", "clause": "L1", "critical": true, "weight": 2 },
+      { "id": "lease-contention-inclusive-expiry", "clause": "L2", "critical": true, "weight": 2 },
+      { "id": "lease-same-owner-reacquire", "clause": "L2", "critical": true, "weight": 2 },
+      { "id": "lease-renew-contract", "clause": "L3", "critical": true, "weight": 2 },
+      { "id": "lease-release-contract", "clause": "L3", "critical": true, "weight": 2 },
+      { "id": "lease-snapshot-isolation", "clause": "L3", "critical": true, "weight": 2 },
+      { "id": "with-lease-success-callback", "clause": "L4", "critical": true, "weight": 2 },
+      { "id": "with-lease-busy", "clause": "L4", "critical": true, "weight": 2 },
+      { "id": "with-lease-failure-cleanup", "clause": "L4", "critical": true, "weight": 2 },
+      { "id": "with-lease-owner-change-cleanup", "clause": "L4", "critical": true, "weight": 2 }
+    ],
+    "resumable-migration-runner": [
+      { "id": "migration-step-validation", "clause": "M1", "critical": true, "weight": 2 },
+      { "id": "migration-dependency-validation", "clause": "M1", "critical": true, "weight": 2 },
+      { "id": "migration-cycle-validation", "clause": "M1", "critical": true, "weight": 2 },
+      { "id": "migration-stable-chain-order", "clause": "M2", "critical": true, "weight": 2 },
+      { "id": "migration-stable-ready-order", "clause": "M2", "critical": true, "weight": 2 },
+      { "id": "migration-input-immutable", "clause": "M2", "critical": true, "weight": 2 },
+      { "id": "migration-runner-input-validation", "clause": "M3", "critical": true, "weight": 2 },
+      { "id": "migration-checkpoint-validation", "clause": "M3", "critical": true, "weight": 2 },
+      { "id": "migration-skip-write-return", "clause": "M3", "critical": true, "weight": 2 },
+      { "id": "migration-crash-resume", "clause": "M4", "critical": true, "weight": 2 },
+      { "id": "migration-return-isolation", "clause": "M4", "critical": true, "weight": 2 }
+    ]
+  }
+}

package/benchmarks/capability-v1/suite.json

@@ -0,0 +1,88 @@
+{
+  "schemaVersion": 2,
+  "id": "capability-v1",
+  "title": "Piagent Public Capability V1 · Calibrated Contract Revision",
+  "description": "Unsaturated multi-file capability tasks with explicit atomic weighted rubrics for diagnosis and hill-climbing; not a release or generalization gate. Historical runs remain identified by their pinned suite digest.",
+  "profile": "node-typescript",
+  "defaultRepeats": 3,
+  "timeoutSeconds": 1200,
+  "assurance": {
+    "taskSource": "maintainer-authored-multi-component-capability-archetypes",
+    "visibility": "public-suite-with-run-private-oracles",
+    "claimTier": "capability",
+    "generatedVariants": true,
+    "familyDisjointSplit": false,
+    "reviewed": true,
+    "refreshedAt": "2026-08-09"
+  },
+  "releaseGate": {
+    "minimumQualityScore": 8,
+    "minimumSafetyScore": 10,
+    "minimumReliabilityScore": 8,
+    "minimumWorkflowScore": 9,
+    "minimumCategoryScore": 7,
+    "minimumOutcomeScoreExclusive": 9.5,
+    "minimumPairedScenarios": 4,
+    "minimumComparableEfficiencyScenarios": 2,
+    "minimumRepeats": 3,
+    "requireEfficiencyClaim": false
+  },
+  "scenarios": [
+    {
+      "id": "multi-package-rollout",
+      "title": "Multi-package feature rollout contract",
+      "kind": "source-change",
+      "category": "platform",
+      "difficulty": "large",
+      "profile": "fullstack",
+      "lifecycle": "cold-start",
+      "fixture": "project",
+      "prompt": "prompts/multi-package-rollout.md",
+      "grader": "grade.mjs",
+      "variantGenerator": "variant.mjs",
+      "allowedChanges": ["packages/policy/src/**", "packages/api/src/**", "apps/admin/src/**", "test/**"]
+    },
+    {
+      "id": "fullstack-search-contract",
+      "title": "Shared backend/frontend search contract",
+      "kind": "source-change",
+      "category": "fullstack",
+      "difficulty": "large",
+      "profile": "fullstack",
+      "lifecycle": "steady-state",
+      "fixture": "project",
+      "prompt": "prompts/fullstack-search-contract.md",
+      "grader": "grade.mjs",
+      "variantGenerator": "variant.mjs",
+      "allowedChanges": ["packages/shared/src/**", "services/catalog/src/**", "apps/web/src/**", "test/**"]
+    },
+    {
+      "id": "concurrent-lease-lifecycle",
+      "title": "Concurrent lease lifecycle and cleanup",
+      "kind": "source-change",
+      "category": "reliability",
+      "difficulty": "large",
+      "profile": "backend-api",
+      "lifecycle": "steady-state",
+      "fixture": "project",
+      "prompt": "prompts/concurrent-lease-lifecycle.md",
+      "grader": "grade.mjs",
+      "variantGenerator": "variant.mjs",
+      "allowedChanges": ["packages/lease/src/**", "test/**"]
+    },
+    {
+      "id": "resumable-migration-runner",
+      "title": "Idempotent resumable migration runner",
+      "kind": "source-change",
+      "category": "data",
+      "difficulty": "large",
+      "profile": "node-typescript",
+      "lifecycle": "cold-start",
+      "fixture": "project",
+      "prompt": "prompts/resumable-migration-runner.md",
+      "grader": "grade.mjs",
+      "variantGenerator": "variant.mjs",
+      "allowedChanges": ["packages/migration/src/**", "test/**"]
+    }
+  ]
+}

package/benchmarks/capability-v1/variant.mjs

@@ -0,0 +1,48 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+
+const [, oraclePath, seed, scenarioId] = process.argv.slice(2);
+if (!oraclePath || !seed || !scenarioId) throw new Error("variant generator arguments are incomplete");
+
+let counter = 0;
+function bytes() {
+  counter += 1;
+  return crypto.createHash("sha256").update(`${seed}:${scenarioId}:${counter}`).digest();
+}
+function integer(minimum, maximum) {
+  return minimum + (bytes().readUInt32BE(0) % (maximum - minimum + 1));
+}
+function token(prefix) {
+  return `${prefix}-${bytes().toString("hex").slice(0, 8)}`;
+}
+
+const oracle = { schemaVersion: 1, graderData: {} };
+if (scenarioId === "multi-package-rollout") {
+  oracle.graderData = {
+    tenantA: token("tenant"),
+    tenantB: token("tenant"),
+    percentage: integer(15, 85),
+    bucketIn: integer(0, 10),
+    bucketOut: integer(90, 99)
+  };
+} else if (scenarioId === "fullstack-search-contract") {
+  oracle.graderData = {
+    idA: token("item"),
+    idB: token("item"),
+    marker: token("marker")
+  };
+} else if (scenarioId === "concurrent-lease-lifecycle") {
+  oracle.graderData = {
+    key: token("lease"),
+    ownerA: token("owner"),
+    ownerB: token("owner"),
+    now: integer(1_000, 9_000),
+    ttlMs: integer(10, 500)
+  };
+} else if (scenarioId === "resumable-migration-runner") {
+  oracle.graderData = {
+    ids: [token("prepare"), token("transform"), token("finalize")]
+  };
+} else throw new Error(`unsupported capability scenario ${scenarioId}`);
+
+fs.writeFileSync(oraclePath, `${JSON.stringify(oracle)}\n`, { mode: 0o600 });

package/benchmarks/e2-framework-v1/alternatives/hono-accessible-search/apps/web/src/search-app.js

@@ -0,0 +1,20 @@
+import { Hono } from "../../../vendor/hono/dist/index.js";
+
+export const normalizeQuery = (value) => `${value ?? ""}`.normalize("NFD").replaceAll(/\p{M}/gu, "").split(/\s+/u).filter(Boolean).join(" ").toLocaleLowerCase("en-US");
+
+const entities = new Map([["&", "&amp;"], ["<", "&lt;"], [">", "&gt;"], ['"', "&quot;"], ["'", "&#39;"]]);
+const escaped = (value) => `${value}`.replace(/[&<>"']/g, (character) => entities.get(character));
+const matches = (item, query) => [item?.name].concat(Array.isArray(item?.tags) ? item.tags : []).filter((value) => typeof value === "string").some((value) => normalizeQuery(value).includes(query));
+
+export function createSearchApp(configuration = {}) {
+  const app = new Hono();
+  app.get("/search", ({ req, html, json }) => {
+    const raw = req.query("q") || "";
+    const specified = req.query("limit");
+    const maximum = specified == null ? 20 : +specified;
+    if (!Array.isArray(configuration.items) || !Number.isSafeInteger(maximum) || maximum <= 0 || maximum > 100) return json({ error: "invalid-request" }, 400);
+    const body = configuration.items.filter((item) => matches(item, normalizeQuery(raw))).slice(0, maximum).reduce((output, item) => output + `<li data-id="${escaped(item.id)}">${escaped(item.name)}</li>`, "");
+    return html(`<form aria-label="Search"><label>Query <input name="q" value="${escaped(raw)}"></label></form><ul aria-label="Search results">${body}</ul>`);
+  });
+  return app;
+}

package/benchmarks/e2-framework-v1/alternatives/hono-tenant-api/apps/api/src/tenant-app.js

@@ -0,0 +1,27 @@
+import { Hono } from "../../../vendor/hono/dist/index.js";
+
+function normalized(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+export function createTenantApp(options = {}) {
+  const repository = Object.hasOwn(options, "users") ? options.users : [];
+  const app = new Hono();
+  app.use("/tenants/:tenantId/users/:userId", async (context, next) => {
+    if (!Array.isArray(repository)) return context.json({ error: "invalid-request" }, 400);
+    const values = [context.req.param("tenantId"), context.req.param("userId"), context.req.header("x-tenant-id"), context.req.header("x-role")].map(normalized);
+    if (values.some((value) => value.length === 0)) return context.json({ error: "invalid-request" }, 400);
+    const [tenantId, , callerTenant, role] = values;
+    if (tenantId !== callerTenant || (role !== "owner" && role !== "admin")) return context.json({ error: "forbidden" }, 403);
+    context.set("identity", values);
+    return next();
+  });
+  app.get("/tenants/:tenantId/users/:userId", (context) => {
+    const [tenantId, userId] = context.get("identity");
+    const record = repository.find(({ id, tenantId: owner }) => normalized(id) === userId && normalized(owner) === tenantId);
+    return !record || record.active !== true
+      ? context.json({ error: "not-found" }, 404)
+      : context.json({ id: normalized(record.id), tenantId: normalized(record.tenantId), name: `${record.name}` });
+  });
+  return app;
+}

package/benchmarks/e2-framework-v1/alternatives/sqlite-resumable-inventory/packages/migration/src/inventory.js

@@ -0,0 +1,34 @@
+const assertDatabase = (value) => {
+  if (typeof value?.prepare !== "function" || typeof value?.exec !== "function") throw new TypeError("invalid database");
+};
+
+export function migrateInventory(db, options = {}) {
+  assertDatabase(db);
+  if (options === null || typeof options !== "object" || Array.isArray(options)) throw new TypeError("invalid options");
+  const stopAt = options.crashAfter;
+  if (stopAt != null && (!Number.isSafeInteger(stopAt) || stopAt < 1)) throw new TypeError("invalid crash point");
+  const hasMeta = Boolean(db.prepare("SELECT name FROM sqlite_master WHERE name = ? AND type = 'table'").get("migration_metadata"));
+  if (hasMeta) {
+    const complete = db.prepare("SELECT value FROM migration_metadata WHERE key = ?").get("inventory-version");
+    if (complete?.value === 2) return { version: 2, migrated: 0 };
+  }
+  db.exec("BEGIN");
+  try {
+    db.exec("CREATE TABLE inventory_v2(id TEXT PRIMARY KEY,label TEXT NOT NULL,quantity INTEGER NOT NULL)");
+    db.exec("CREATE TABLE migration_metadata(key TEXT PRIMARY KEY,value INTEGER NOT NULL)");
+    const source = db.prepare("SELECT id,name,quantity FROM inventory ORDER BY rowid").all();
+    const target = db.prepare("INSERT INTO inventory_v2 VALUES(?,?,?)");
+    source.forEach((row, index) => {
+      const converted = { id: typeof row.id === "string" ? row.id.trim() : "", label: typeof row.name === "string" ? row.name.trim() : "", quantity: Number(row.quantity) };
+      if (!converted.id || !converted.label || !Number.isSafeInteger(converted.quantity) || converted.quantity < 0) throw new TypeError("bad row");
+      target.run(converted.id, converted.label, converted.quantity);
+      if (index + 1 === stopAt) throw new Error("injected migration crash");
+    });
+    db.prepare("INSERT INTO migration_metadata VALUES(?,?)").run("inventory-version", 2);
+    db.exec("COMMIT");
+    return { version: 2, migrated: source.length };
+  } catch (cause) {
+    db.exec("ROLLBACK");
+    throw cause;
+  }
+}

package/benchmarks/e2-framework-v1/alternatives/workspace-policy-rollout/apps/admin/src/summary.js

@@ -0,0 +1,6 @@
+import * as rollout from "../../../packages/policy/src/rollout.js";
+
+export const renderPolicySummary = (input) => {
+  const { enabled, percentage, tenants } = rollout.normalizePolicy(input);
+  return ["enabled=" + enabled, "percentage=" + percentage, "tenants=" + tenants.join(",")].join("; ");
+};

package/benchmarks/e2-framework-v1/alternatives/workspace-policy-rollout/packages/feature-api/src/evaluate.js

@@ -0,0 +1,14 @@
+import * as policyEngine from "../../policy/src/rollout.js";
+
+export function evaluateFeature(input, subject) {
+  const policy = policyEngine.normalizePolicy(input);
+  if (!policy.enabled) return { allowed: false, reason: "disabled" };
+  if (subject == null) return { allowed: false, reason: "not-eligible" };
+  const tenant = typeof subject.tenantId === "string" ? subject.tenantId.trim() : "";
+  if (policy.tenants.indexOf(tenant) !== -1) {
+    policyEngine.isEnabled(policy, subject);
+    return { allowed: true, reason: "tenant-override" };
+  }
+  const allowed = policyEngine.isEnabled(policy, subject);
+  return { allowed, reason: allowed ? "percentage" : "not-eligible" };
+}

package/benchmarks/e2-framework-v1/alternatives/workspace-policy-rollout/packages/policy/src/rollout.js

@@ -0,0 +1,18 @@
+const validPercentage = (value) => Number.isSafeInteger(value) && value >= 0 && value <= 100;
+
+export function normalizePolicy(source) {
+  if (source === null || typeof source !== "object" || Array.isArray(source) || !validPercentage(source.percentage) || !Array.isArray(source.tenants)) throw new TypeError("invalid policy");
+  const tenants = [...new Set(source.tenants.map((tenant) => {
+    if (typeof tenant !== "string" || tenant.trim().length === 0) throw new TypeError("invalid tenant");
+    return tenant.trim();
+  }))];
+  return Object.assign({}, { enabled: !!source.enabled, percentage: source.percentage, tenants });
+}
+
+export function isEnabled(policy, subject) {
+  const value = normalizePolicy(policy);
+  if (!value.enabled || subject == null) return false;
+  const { bucket, tenantId } = subject;
+  if (!Number.isSafeInteger(bucket) || bucket < 0 || bucket >= 100) throw new TypeError("invalid bucket");
+  return new Set(value.tenants).has(typeof tenantId === "string" ? tenantId.trim() : "") ? true : bucket < value.percentage;
+}

package/benchmarks/e2-framework-v1/coverage.json

@@ -0,0 +1,25 @@
+{
+  "schemaVersion": 1,
+  "checks": {
+    "tenant-hono-route": "Proves that the implementation uses the pinned Hono request lifecycle and registers the exact parameterized route.",
+    "tenant-authorization": "Kills tenant-boundary and role regressions by exercising matching, mismatching, absent, and unsupported caller identities.",
+    "tenant-validation": "Covers malformed repositories and blank path or header values so validation cannot be replaced by permissive coercion.",
+    "tenant-response-contract": "Distinguishes active, inactive, missing, and successful records while enforcing the exact public response projection.",
+    "tenant-immutability": "Detects caller mutation and leaked object identity across repeated framework requests with independently cloned observations.",
+    "search-normalization": "Exercises decomposed Unicode marks, Unicode whitespace, nullish values, and non-string values through the public normalizer.",
+    "search-hono-route": "Proves real Hono routing, normalized name and string-tag matching, stable input order, and an HTML content type.",
+    "search-limit-contract": "Kills default, boundary, fractional, zero, negative, oversized, and repeated-query limit parsing regressions.",
+    "search-accessible-escaping": "Requires both accessible form/list structure and exact escaping of every dangerous HTML character in all public fields.",
+    "search-empty-immutable": "Distinguishes a valid empty result from missing markup while detecting mutation of nested caller-owned item data.",
+    "inventory-schema-migration": "Uses a real in-memory Node SQLite database to prove the new schema, metadata version, and converted row contract.",
+    "inventory-validation-atomicity": "Injects invalid legacy rows and proves the transaction leaves no partial table, metadata, or converted records.",
+    "inventory-idempotency": "Runs migration twice against the same real database and rejects duplicate writes or nonzero repeated migration counts.",
+    "inventory-crash-resume": "Injects a deterministic mid-transaction crash, checks complete rollback, and then proves a normal retry can finish.",
+    "inventory-preserves-legacy": "Checks legacy schema and exact legacy rows after migration and statically requires prepared statements plus transaction control.",
+    "policy-normalized-shape": "Checks exact output keys, boolean conversion, trim and first-seen deduplication, fresh identity, and input immutability.",
+    "policy-validation": "Exercises null, arrays, percentage boundaries, unsafe numbers, malformed tenant containers, and blank tenant elements.",
+    "policy-enablement": "Covers disabled and missing subjects, tenant override, exclusive percentage boundaries, and invalid bucket values.",
+    "policy-api-reasons": "Requires the cross-package import and each exact decision reason without swallowing policy-layer validation errors.",
+    "policy-admin-summary": "Requires the admin package to reuse normalization and emit the exact stable summary including deduplicated tenants."
+  }
+}