@piagent/platform 1.5.5 → 1.6.0

package/benchmarks/deep-logic-v1/grade.mjs

@@ -11,6 +11,13 @@ const data = oracle.graderData;
 const checks = [];
 async function check(id, action) { try { await action(); checks.push({ id, passed: true }); } catch { checks.push({ id, passed: false }); } }
 async function load(file) { const url = pathToFileURL(path.join(workspace, file)); url.searchParams.set("benchmark", `${Date.now()}-${Math.random()}`); return import(url.href); }
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
 
 switch (scenario) {
   case "revision-event-reconciliation": {
@@ -109,29 +116,97 @@ switch (scenario) {
   }
   case "resumable-stream-assembly": {
     const { assembleStream } = await load("src/stream.js");
-    await check("interleaved-replay-and-gap", () => {
-      const snapshot = { cursor: 2, messages: [{ id: data.message, text: data.first, complete: false }] };
+    await check("contiguous-interleaving-exact-duplicates-and-order", () => {
+      const snapshot = { cursor: data.start, messages: [{ id: data.message, text: data.first, complete: false }] };
+      const first = {
+        cursor: data.start + 1,
+        messageId: data.message,
+        offset: data.first.length,
+        text: data.second,
+        complete: false
+      };
+      const second = {
+        cursor: data.start + 2,
+        messageId: data.other,
+        offset: 0,
+        text: data.third,
+        complete: false
+      };
+      const final = {
+        cursor: data.start + 3,
+        messageId: data.message,
+        offset: (data.first + data.second).length,
+        text: "",
+        complete: true
+      };
+      const events = [second, first, structuredClone(second), final];
+      const before = structuredClone([snapshot, events]), result = assembleStream(snapshot, events);
+      assert.deepEqual([snapshot, events], before);
+      assert.equal(result.cursor, data.start + 3);
+      assert.deepEqual(result.messages, [
+        { id: data.message, text: data.first + data.second, complete: true },
+        { id: data.other, text: data.third, complete: false }
+      ]);
+      assert.deepEqual(result.appliedCursors, [data.start + 1, data.start + 2, data.start + 3]);
+      assert.deepEqual(result.replayedCursors, []);
+      assert.deepEqual(result.buffered, []);
+      assert.equal(result.gap, null);
+    });
+    await check("replay-gap-and-buffer-order", () => {
+      const snapshot = { cursor: data.start, messages: [] };
+      const replay = { cursor: data.start, messageId: "replay", offset: 0, text: "old", complete: false };
       const events = [
-        { cursor: 5, messageId: "other", offset: 0, text: "late", complete: false },
-        { cursor: 1, messageId: data.message, offset: 0, text: "old", complete: false },
-        { cursor: 3, messageId: data.message, offset: data.first.length, text: data.second, complete: true }
+        { cursor: data.start + 3, messageId: "late-b", offset: 0, text: data.second, complete: false },
+        replay,
+        { cursor: data.start + 2, messageId: "late-a", offset: 0, text: data.first, complete: false },
+        structuredClone(replay)
       ];
       const before = structuredClone([snapshot, events]), result = assembleStream(snapshot, events);
       assert.deepEqual([snapshot, events], before);
-      assert.equal(result.cursor, 3); assert.equal(result.messages[0].text, data.first + data.second); assert.equal(result.messages[0].complete, true);
-      assert.deepEqual(result.appliedCursors, [3]); assert.deepEqual(result.replayedCursors, [1]);
-      assert.deepEqual(result.gap, { expected: 4, observed: 5 }); assert.equal(result.buffered[0].cursor, 5);
+      assert.equal(result.cursor, data.start);
+      assert.deepEqual(result.appliedCursors, []);
+      assert.deepEqual(result.replayedCursors, [data.start]);
+      assert.deepEqual(result.buffered.map((event) => event.cursor), [data.start + 2, data.start + 3]);
+      assert.deepEqual(result.gap, { expected: data.start + 1, observed: data.start + 2 });
     });
-    await check("offset-completion-and-cursor-conflicts", () => {
+    await check("utf16-offset-and-empty-finalization", () => {
+      const initial = `${data.astral}${data.first}`;
+      const snapshot = { cursor: 0, messages: [{ id: data.message, text: initial, complete: false }] };
+      const events = [{ cursor: 1, messageId: data.message, offset: initial.length, text: data.second, complete: true }];
+      const result = assembleStream(snapshot, events);
+      assert.equal(result.messages[0].text, initial + data.second);
+      assert.equal(result.messages[0].complete, true);
+      const emptyFinal = assembleStream(
+        { cursor: 0, messages: [{ id: data.other, text: initial, complete: false }] },
+        [{ cursor: 1, messageId: data.other, offset: initial.length, text: "", complete: true }]
+      );
+      assert.equal(emptyFinal.messages[0].text, initial);
+      assert.equal(emptyFinal.messages[0].complete, true);
+    });
+    await check("invalid-offset-rejected", () => {
       const base = { cursor: 0, messages: [] };
       assert.throws(() => assembleStream(base, [{ cursor: 1, messageId: "m", offset: 1, text: "x", complete: false }]));
+    });
+    await check("conflicting-cursor-rejected", () => {
+      const base = { cursor: 0, messages: [] };
       assert.throws(() => assembleStream(base, [
         { cursor: 1, messageId: "m", offset: 0, text: "x", complete: false },
         { cursor: 1, messageId: "m", offset: 0, text: "y", complete: false }
       ]));
+    });
+    await check("event-after-completion-rejected", () => {
       assert.throws(() => assembleStream({ cursor: 0, messages: [{ id: "m", text: "x", complete: true }] },
         [{ cursor: 1, messageId: "m", offset: 1, text: "", complete: true }]));
     });
+    await check("input-shape-validation", () => {
+      assert.throws(() => assembleStream({ cursor: -1, messages: [] }, []));
+      assert.throws(() => assembleStream({ cursor: 0, messages: [] }, [
+        { cursor: 1, messageId: "m", offset: Number.MAX_SAFE_INTEGER + 1, text: "x", complete: false }
+      ]));
+      assert.throws(() => assembleStream({ cursor: 0, messages: [] }, [
+        { cursor: 1, messageId: "m", offset: 0, text: 1, complete: false }
+      ]));
+    });
     break;
   }
   case "transactional-config-merge": {
@@ -142,7 +217,10 @@ switch (scenario) {
       const schema = { service: { type: "object", required: true }, remove: { type: "string" }, enabled: { type: "boolean", default: false } };
       const before = structuredClone([base, layers, schema]), result = planConfigTransaction(base, layers, schema);
       assert.deepEqual([base, layers, schema], before);
-      assert.deepEqual(result.next, { service: { port: 0, stale: true, [data.key]: data.value }, enabled: false });
+      assert.equal(
+        canonicalJson(result.next),
+        canonicalJson({ service: { port: 0, stale: true, [data.key]: data.value }, enabled: false })
+      );
       assert.deepEqual(result.changes.map((item) => item.path), [...result.changes.map((item) => item.path)].sort());
       assert.ok(result.changes.some((item) => item.path === "/remove" && item.kind === "delete"));
       assert.ok(result.changes.some((item) => item.path === "/enabled" && item.kind === "add"));
@@ -158,6 +236,190 @@ switch (scenario) {
     });
     break;
   }
+  case "temporal-usage-billing-close": {
+    const { normalizePlanTimeline } = await load("packages/billing/src/plan-timeline.js");
+    const { closeUsagePeriod } = await load("packages/billing/src/close-period.js");
+    const { billingSummary } = await load("apps/admin/src/billing-summary.js");
+    const period = { start: "2026-08-01T00:00:00.000Z", end: "2026-09-01T00:00:00.000Z" };
+    const [planA1, planA2, planB1] = data.plans;
+    const [price1, price2, price3] = data.prices;
+    const tiers = (prices = data.prices) => [
+      { upTo: data.firstLimit, unitPriceMicros: prices[0] },
+      { upTo: data.secondLimit, unitPriceMicros: prices[1] },
+      { upTo: null, unitPriceMicros: prices[2] }
+    ];
+    const plan = ({ id, tenantId, effectiveAt, currency = "USD", meters = { [data.meter]: tiers() } }) => (
+      { id, tenantId, currency, effectiveAt, meters }
+    );
+    const plans = () => [
+      plan({ id: planA2, tenantId: data.tenantA, effectiveAt: "2026-08-15T00:00:00.000Z" }),
+      plan({ id: planB1, tenantId: data.tenantB, effectiveAt: "2026-07-01T00:00:00.000Z" }),
+      plan({ id: planA1, tenantId: data.tenantA, effectiveAt: "2026-07-01T00:00:00.000Z" })
+    ];
+    const usage = (id, tenantId, at, units, meter = data.meter) => ({ id, kind: "usage", tenantId, meter, at, units });
+    const reversal = (id, tenantId, at, targetId) => ({ id, kind: "reversal", tenantId, at, targetId });
+    const canonical = (value) => {
+      if (value === null || typeof value === "string" || typeof value === "boolean" || Number.isSafeInteger(value)) return JSON.stringify(value);
+      if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+      return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+    };
+    await check("period-and-timeline-normalization", () => {
+      const source = plans();
+      source[0].meters = { zeta: tiers(), [data.meter]: tiers() };
+      const before = structuredClone(source), normalized = normalizePlanTimeline(source, period);
+      assert.deepEqual(source, before);
+      assert.notEqual(normalized.find((item) => item.id === planA1), source[2]);
+      assert.deepEqual(normalized.map((item) => item.id), before.toSorted((left, right) => left.tenantId.localeCompare(right.tenantId)
+        || left.effectiveAt.localeCompare(right.effectiveAt) || left.id.localeCompare(right.id)).map((item) => item.id));
+      assert.deepEqual(Object.keys(normalized.find((item) => item.id === planA2).meters), [data.meter, "zeta"].sort());
+      assert.deepEqual(Object.keys(normalized[0]), ["id", "tenantId", "currency", "effectiveAt", "meters"]);
+    });
+    await check("timeline-validation-fail-closed", () => {
+      assert.throws(() => normalizePlanTimeline(plans(), { start: period.end, end: period.start }), TypeError);
+      assert.throws(() => normalizePlanTimeline([plans()[0], { ...plans()[1], id: plans()[0].id }], period), TypeError);
+      assert.throws(() => normalizePlanTimeline([plans()[0], { ...plans()[2], effectiveAt: plans()[0].effectiveAt }], period), TypeError);
+      assert.throws(() => normalizePlanTimeline([plans()[2], { ...plans()[0], currency: "EUR" }], period), TypeError);
+      assert.throws(() => normalizePlanTimeline([plan({ id: "bad", tenantId: data.tenantA, effectiveAt: "2026-07-01T00:00:00.000Z", meters: { [data.meter]: [{ upTo: 3, unitPriceMicros: 1 }] } })], period), TypeError);
+      assert.throws(() => normalizePlanTimeline([plan({ id: "bad", tenantId: data.tenantA, effectiveAt: "2026-07-01", meters: { [data.meter]: tiers() } })], period), TypeError);
+    });
+    await check("tier-boundary-and-multi-tier-allocation", () => {
+      const firstUnits = data.firstLimit - 1, secondUnits = data.secondLimit - data.firstLimit + 3;
+      const result = closeUsagePeriod({ period, plans: plans(), events: [
+        usage("u-1", data.tenantA, "2026-08-02T00:00:00.000Z", firstUnits),
+        usage("u-2", data.tenantA, "2026-08-03T00:00:00.000Z", secondUnits)
+      ] });
+      const [first, second] = result.invoices[0].lines;
+      assert.deepEqual(first.allocations, [{ tierIndex: 0, units: firstUnits, unitPriceMicros: String(price1), chargeMicros: String(BigInt(firstUnits) * BigInt(price1)) }]);
+      assert.deepEqual(second.allocations.map((item) => [item.tierIndex, item.units]), [
+        [0, 1], [1, data.secondLimit - data.firstLimit], [2, 2]
+      ]);
+      assert.equal(second.chargeMicros, String(BigInt(price1) + BigInt(data.secondLimit - data.firstLimit) * BigInt(price2) + 2n * BigInt(price3)));
+    });
+    await check("effective-boundary-and-plan-reset", () => {
+      const result = closeUsagePeriod({ period, plans: plans(), events: [
+        usage("before", data.tenantA, "2026-08-14T23:59:59.999Z", data.firstLimit),
+        usage("boundary", data.tenantA, "2026-08-15T00:00:00.000Z", data.firstLimit + 1)
+      ] });
+      const [before, boundary] = result.invoices[0].lines;
+      assert.equal(before.planId, planA1); assert.equal(boundary.planId, planA2);
+      assert.deepEqual(boundary.allocations.map((item) => [item.tierIndex, item.units]), [[0, data.firstLimit], [1, 1]]);
+    });
+    await check("tenant-and-meter-counter-isolation", () => {
+      const otherMeter = `${data.meter}-secondary`;
+      const expanded = plans().map((item) => ({ ...item, meters: { ...item.meters, [otherMeter]: tiers() } }));
+      const result = closeUsagePeriod({ period, plans: expanded, events: [
+        usage("a-main", data.tenantA, "2026-08-02T00:00:00.000Z", data.firstLimit),
+        usage("a-other", data.tenantA, "2026-08-03T00:00:00.000Z", data.firstLimit, otherMeter),
+        usage("b-main", data.tenantB, "2026-08-02T00:00:00.000Z", data.firstLimit)
+      ] });
+      assert.equal(result.invoices.length, 2);
+      for (const invoice of result.invoices) for (const line of invoice.lines) {
+        assert.deepEqual(line.allocations.map((item) => item.tierIndex), [0]);
+      }
+    });
+    await check("reversal-applied-before-rating", () => {
+      const result = closeUsagePeriod({ period, plans: plans(), events: [
+        reversal("reverse-first", data.tenantA, "2026-08-10T00:00:00.000Z", "charged-first"),
+        usage("charged-second", data.tenantA, "2026-08-03T00:00:00.000Z", data.firstLimit),
+        usage("charged-first", data.tenantA, "2026-08-02T00:00:00.000Z", data.firstLimit)
+      ] });
+      assert.deepEqual(result.reversedEventIds, ["charged-first"]);
+      assert.deepEqual(result.invoices[0].lines.map((item) => item.eventId), ["charged-second"]);
+      assert.deepEqual(result.invoices[0].lines[0].allocations.map((item) => item.tierIndex), [0]);
+    });
+    await check("reversal-validation", () => {
+      const target = usage("target", data.tenantA, "2026-08-05T00:00:00.000Z", 1);
+      assert.throws(() => closeUsagePeriod({ period, plans: plans(), events: [target, reversal("r", data.tenantB, "2026-08-06T00:00:00.000Z", "target")] }), TypeError);
+      assert.throws(() => closeUsagePeriod({ period, plans: plans(), events: [target, reversal("r", data.tenantA, "2026-08-04T00:00:00.000Z", "target")] }), TypeError);
+      assert.throws(() => closeUsagePeriod({ period, plans: plans(), events: [target, reversal("r1", data.tenantA, "2026-08-06T00:00:00.000Z", "target"), reversal("r2", data.tenantA, "2026-08-07T00:00:00.000Z", "target")] }), TypeError);
+      assert.throws(() => closeUsagePeriod({ period, plans: plans(), events: [reversal("r", data.tenantA, "2026-08-06T00:00:00.000Z", "missing")] }), TypeError);
+    });
+    await check("permutation-independent-canonical-output", () => {
+      const events = [
+        usage("z-last", data.tenantA, "2026-08-04T00:00:00.000Z", 2),
+        usage("a-first", data.tenantA, "2026-08-02T00:00:00.000Z", 2),
+        usage("b-same-time", data.tenantA, "2026-08-02T00:00:00.000Z", 2),
+        usage("tenant-b", data.tenantB, "2026-08-03T00:00:00.000Z", 2)
+      ];
+      const forward = closeUsagePeriod({ period, plans: plans(), events });
+      const reversed = closeUsagePeriod({ period, plans: plans().reverse(), events: [...events].reverse() });
+      assert.deepEqual(reversed, forward);
+      assert.deepEqual(forward.invoices.find((item) => item.tenantId === data.tenantA).lines.map((item) => item.eventId), ["a-first", "b-same-time", "z-last"]);
+    });
+    await check("bigint-charge-exactness", () => {
+      const units = Number.MAX_SAFE_INTEGER, unitPriceMicros = Number.MAX_SAFE_INTEGER;
+      const hugePlan = [plan({ id: planA1, tenantId: data.tenantA, effectiveAt: "2026-07-01T00:00:00.000Z", meters: { [data.meter]: [{ upTo: null, unitPriceMicros }] } })];
+      const result = closeUsagePeriod({ period, plans: hugePlan, events: [usage("huge", data.tenantA, "2026-08-02T00:00:00.000Z", units)] });
+      const expected = BigInt(units) * BigInt(unitPriceMicros);
+      assert.equal(result.invoices[0].lines[0].chargeMicros, String(expected));
+      assert.equal(result.invoices[0].subtotalMicros, String(expected));
+    });
+    await check("round-half-to-even-once", () => {
+      const closeAt = (price) => closeUsagePeriod({ period, plans: [plan({ id: planA1, tenantId: data.tenantA, effectiveAt: "2026-07-01T00:00:00.000Z", meters: { [data.meter]: [{ upTo: null, unitPriceMicros: price }] } })], events: [usage("tie", data.tenantA, "2026-08-02T00:00:00.000Z", 1)] });
+      assert.equal(closeAt(2_500_000).invoices[0].totalMinor, "2");
+      assert.equal(closeAt(3_500_000).invoices[0].totalMinor, "4");
+    });
+    await check("invoice-shape-total-and-nested-digest", () => {
+      const result = closeUsagePeriod({ period, plans: plans(), events: [usage("digest-line", data.tenantA, "2026-08-02T00:00:00.000Z", data.firstLimit + 2)] });
+      assert.deepEqual(Object.keys(result), ["period", "invoices", "reversedEventIds"]);
+      const { digest: observed, ...content } = result.invoices[0];
+      assert.equal(observed, crypto.createHash("sha256").update(canonical(content)).digest("hex"));
+      assert.equal(content.subtotalMicros, String(content.lines.reduce((sum, line) => sum + BigInt(line.chargeMicros), 0n)));
+      const mutated = structuredClone(content); mutated.lines[0].allocations[0].units += 1;
+      assert.notEqual(observed, crypto.createHash("sha256").update(canonical(mutated)).digest("hex"));
+    });
+    await check("input-immutability", () => {
+      const input = { period, plans: plans(), events: [usage("valid", data.tenantA, "2026-08-02T00:00:00.000Z", 1)] };
+      const before = structuredClone(input); closeUsagePeriod(input); assert.deepEqual(input, before);
+      const finalInvalid = { period, plans: plans(), events: [usage("ok", data.tenantA, "2026-08-02T00:00:00.000Z", 1), usage("bad", data.tenantA, period.end, 1)] };
+      const finalBefore = structuredClone(finalInvalid); assert.throws(() => closeUsagePeriod(finalInvalid), TypeError); assert.deepEqual(finalInvalid, finalBefore);
+    });
+    await check("event-validation", () => {
+      for (const invalid of [
+        { ...usage("x", data.tenantA, period.end, 1) },
+        { ...usage("x", data.tenantA, "2026-08-02T00:00:00.000Z", 1), extra: true },
+        { ...usage("x", data.tenantA, "2026-08-02T00:00:00.000Z", 1), units: Number.MAX_SAFE_INTEGER + 1 }
+      ]) assert.throws(() => closeUsagePeriod({ period, plans: plans(), events: [invalid] }), TypeError);
+    });
+    await check("missing-plan-or-meter-fails-closed", () => {
+      assert.throws(() => closeUsagePeriod({
+        period,
+        plans: plans(),
+        events: [usage("missing-meter", data.tenantA, "2026-08-02T00:00:00.000Z", 1, "missing-meter")]
+      }), TypeError);
+      assert.throws(() => closeUsagePeriod({
+        period,
+        plans: plans(),
+        events: [usage("missing-plan", "tenant-without-plan", "2026-08-02T00:00:00.000Z", 1)]
+      }), TypeError);
+    });
+    await check("non-json-and-poison-values-rejected", () => {
+      const sparse = []; sparse.length = 1;
+      assert.throws(() => normalizePlanTimeline(sparse, period), TypeError);
+      const poisonedMeters = JSON.parse(`{"__proto__":[{"upTo":null,"unitPriceMicros":1}]}`);
+      assert.throws(() => normalizePlanTimeline([plan({ id: planA1, tenantId: data.tenantA, effectiveAt: "2026-07-01T00:00:00.000Z", meters: poisonedMeters })], period), TypeError);
+      const invalidPrice = plans(); invalidPrice[0].meters[data.meter][0].unitPriceMicros = Number.NaN;
+      assert.throws(() => normalizePlanTimeline(invalidPrice, period), TypeError);
+      const accessorPeriod = { end: period.end }; Object.defineProperty(accessorPeriod, "start", { enumerable: true, get: () => period.start });
+      assert.throws(() => normalizePlanTimeline(plans(), accessorPeriod), TypeError);
+      const symbolPlan = plans()[0]; symbolPlan[Symbol("hidden")] = true;
+      assert.throws(() => normalizePlanTimeline([symbolPlan], period), TypeError);
+    });
+    await check("terminal-webui-summary-format-parity", () => {
+      const result = closeUsagePeriod({ period, plans: plans(), events: [usage("summary", data.tenantA, "2026-08-02T00:00:00.000Z", 1)] });
+      const invoice = result.invoices[0];
+      assert.equal(billingSummary(result), [
+        `period=${period.start}..${period.end}; invoices=1; reversed=0`,
+        `tenant=${JSON.stringify(data.tenantA)}; currency=USD; lines=1; subtotalMicros=${invoice.subtotalMicros}; totalMinor=${invoice.totalMinor}; digest=${invoice.digest}`
+      ].join("\n"));
+    });
+    await check("terminal-webui-summary-rejects-malformed-result", () => {
+      const result = closeUsagePeriod({ period, plans: plans(), events: [usage("summary-invalid", data.tenantA, "2026-08-02T00:00:00.000Z", 1)] });
+      const invoice = result.invoices[0];
+      assert.throws(() => billingSummary({ ...result, invoices: [{ ...invoice, digest: "wrong" }] }), TypeError);
+    });
+    break;
+  }
   default: throw new Error(`unsupported deep logic scenario ${scenario}`);
 }
 

package/benchmarks/deep-logic-v1/project/apps/admin/src/billing-summary.js

@@ -0,0 +1,3 @@
+export function billingSummary(_result) {
+  throw new Error("not implemented");
+}

package/benchmarks/deep-logic-v1/project/benchmark-contract/public-smoke.test.js

@@ -0,0 +1,166 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { billingSummary } from "../apps/admin/src/billing-summary.js";
+import { closeUsagePeriod } from "../packages/billing/src/close-period.js";
+import { normalizePlanTimeline } from "../packages/billing/src/plan-timeline.js";
+import { planConfigTransaction } from "../src/config-transaction.js";
+import { buildContextPack } from "../src/context-pack.js";
+import { reconcileSession } from "../src/event-reconcile.js";
+import { decideAccess } from "../src/policy.js";
+import { scheduleJobs } from "../src/scheduler.js";
+import { assembleStream } from "../src/stream.js";
+
+const scenario = process.env.PIAGENT_BENCHMARK_SCENARIO;
+
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+test("the selected benchmark entrypoint handles a fixed public happy path", { skip: !scenario }, () => {
+  switch (scenario) {
+    case "revision-event-reconciliation": {
+      const snapshot = { revision: "r0", nextSequence: 1, state: { keep: true } };
+      const events = [{ id: "e1", sequence: 1, baseRevision: "r0", revision: "r1", patch: { value: 1 } }];
+      const before = structuredClone([snapshot, events]);
+      assert.equal(canonicalJson(reconcileSession(snapshot, events)), canonicalJson({
+        revision: "r1",
+        nextSequence: 2,
+        state: { keep: true, value: 1 },
+        appliedIds: ["e1"],
+        duplicateIds: [],
+        pending: [],
+        gap: null
+      }));
+      assert.deepEqual([snapshot, events], before);
+      break;
+    }
+    case "fair-dependency-scheduler": {
+      const jobs = [{ id: "job-1", tenant: "tenant-a", weight: 1, dependsOn: [] }];
+      const before = structuredClone(jobs);
+      assert.deepEqual(scheduleJobs(jobs, 1), [["job-1"]]);
+      assert.deepEqual(jobs, before);
+      break;
+    }
+    case "layered-policy-resolution": {
+      const result = decideAccess({ path: "lib/tool.js", operation: "inspect" }, [
+        { name: "local", rules: [{ pattern: "lib/*", operations: ["inspect"], effect: "allow" }] }
+      ]);
+      assert.equal(result.allowed, true);
+      assert.equal(result.effect, "allow");
+      assert.equal(result.layer, "local");
+      assert.equal(result.ruleIndex, 0);
+      assert.equal(result.protected, false);
+      assert.equal(typeof result.reason, "string");
+      break;
+    }
+    case "budgeted-context-graph": {
+      const nodes = [{ id: "note", path: "notes/item.txt", text: "Needle note", tokens: 1 }];
+      const before = structuredClone(nodes);
+      const result = buildContextPack(
+        "needle",
+        nodes,
+        [],
+        1
+      );
+      assert.deepEqual(result.selected.map((item) => item.id), ["note"]);
+      assert.equal(result.selected[0].directScore, 1);
+      assert.equal(result.selected[0].score, 1);
+      assert.equal(result.usedTokens, 1);
+      assert.deepEqual(result.omitted, []);
+      assert.equal(result.confidence, "high");
+      assert.deepEqual(nodes, before);
+      break;
+    }
+    case "resumable-stream-assembly": {
+      const snapshot = { cursor: 0, messages: [] };
+      const events = [{ cursor: 1, messageId: "m1", offset: 0, text: "hello", complete: true }];
+      const before = structuredClone([snapshot, events]);
+      assert.equal(canonicalJson(assembleStream(snapshot, events)), canonicalJson({
+        cursor: 1,
+        messages: [{ id: "m1", text: "hello", complete: true }],
+        appliedCursors: [1],
+        replayedCursors: [],
+        buffered: [],
+        gap: null
+      }));
+      assert.deepEqual([snapshot, events], before);
+
+      const openSnapshot = { cursor: 0, messages: [{ id: "open", text: "ready", complete: false }] };
+      const emptyFinal = [{ cursor: 1, messageId: "open", offset: 5, text: "", complete: true }];
+      assert.equal(canonicalJson(assembleStream(openSnapshot, emptyFinal)), canonicalJson({
+        cursor: 1,
+        messages: [{ id: "open", text: "ready", complete: true }],
+        appliedCursors: [1],
+        replayedCursors: [],
+        buffered: [],
+        gap: null
+      }));
+
+      const completedSnapshot = { cursor: 0, messages: [{ id: "done", text: "ready", complete: true }] };
+      const completedEvents = [{ cursor: 1, messageId: "done", offset: 5, text: "", complete: true }];
+      assert.throws(() => assembleStream(completedSnapshot, completedEvents));
+      break;
+    }
+    case "transactional-config-merge": {
+      const base = { label: "old", legacy: true };
+      const layers = [{ label: "new", legacy: { $delete: true } }];
+      const schema = {
+        label: { type: "string", required: true },
+        legacy: { type: "boolean" }
+      };
+      const before = structuredClone([base, layers, schema]);
+      const result = planConfigTransaction(
+        base,
+        layers,
+        schema
+      );
+      assert.equal(canonicalJson(result.next), canonicalJson({ label: "new" }));
+      assert.ok(result.changes.some((item) => item.path === "/label" && item.kind === "replace"));
+      assert.ok(result.changes.some((item) => item.path === "/legacy" && item.kind === "delete"));
+      assert.match(result.digest, /^[a-f0-9]{64}$/);
+      assert.deepEqual([base, layers, schema], before);
+      break;
+    }
+    case "temporal-usage-billing-close": {
+      const period = { start: "2025-01-01T00:00:00.000Z", end: "2025-02-01T00:00:00.000Z" };
+      const plans = [{
+        id: "basic",
+        tenantId: "customer-1",
+        currency: "USD",
+        effectiveAt: "2024-12-01T00:00:00.000Z",
+        meters: { requests: [{ upTo: null, unitPriceMicros: 1_000_000 }] }
+      }];
+      const normalized = normalizePlanTimeline(plans, period);
+      assert.equal(canonicalJson(normalized), canonicalJson(plans));
+      assert.notEqual(normalized[0], plans[0]);
+      const result = closeUsagePeriod({
+        period,
+        plans,
+        events: [{
+          id: "usage-1",
+          kind: "usage",
+          tenantId: "customer-1",
+          meter: "requests",
+          at: "2025-01-02T00:00:00.000Z",
+          units: 2
+        }]
+      });
+      assert.equal(result.invoices.length, 1);
+      assert.equal(result.invoices[0].subtotalMicros, "2000000");
+      assert.equal(result.invoices[0].totalMinor, "2");
+      assert.match(result.invoices[0].digest, /^[a-f0-9]{64}$/);
+      assert.deepEqual(billingSummary(result).split("\n"), [
+        `period=${period.start}..${period.end}; invoices=1; reversed=0`,
+        `tenant="customer-1"; currency=USD; lines=1; subtotalMicros=2000000; totalMinor=2; digest=${result.invoices[0].digest}`
+      ]);
+      break;
+    }
+    default:
+      assert.fail(`unsupported benchmark scenario ${scenario}`);
+  }
+});

package/benchmarks/deep-logic-v1/project/package.json

@@ -2,5 +2,5 @@
   "name": "piagent-deep-logic-fixture",
   "private": true,
   "type": "module",
-  "scripts": { "test": "node --test test/*.test.js" }
+  "scripts": { "test": "node --test benchmark-contract/*.test.js test/*.test.js" }
 }

package/benchmarks/deep-logic-v1/project/packages/billing/src/close-period.js

@@ -0,0 +1,3 @@
+export function closeUsagePeriod(_input) {
+  throw new Error("not implemented");
+}

package/benchmarks/deep-logic-v1/project/packages/billing/src/plan-timeline.js

@@ -0,0 +1,3 @@
+export function normalizePlanTimeline(_plans, _period) {
+  throw new Error("not implemented");
+}

package/benchmarks/deep-logic-v1/project/test/smoke.test.js

@@ -7,6 +7,9 @@ import { reconcileSession } from "../src/event-reconcile.js";
 import { decideAccess } from "../src/policy.js";
 import { scheduleJobs } from "../src/scheduler.js";
 import { assembleStream } from "../src/stream.js";
+import { billingSummary } from "../apps/admin/src/billing-summary.js";
+import { closeUsagePeriod } from "../packages/billing/src/close-period.js";
+import { normalizePlanTimeline } from "../packages/billing/src/plan-timeline.js";
 
 test("every benchmark entrypoint loads before private grading", () => {
   for (const entrypoint of [
@@ -15,6 +18,9 @@ test("every benchmark entrypoint loads before private grading", () => {
     reconcileSession,
     decideAccess,
     scheduleJobs,
-    assembleStream
+    assembleStream,
+    normalizePlanTimeline,
+    closeUsagePeriod,
+    billingSummary
   ]) assert.equal(typeof entrypoint, "function");
 });

package/benchmarks/deep-logic-v1/prompts/budgeted-context-graph.md

@@ -11,3 +11,5 @@ Required behavior:
 - Return `{ selected, usedTokens, omitted, confidence }`; selected/omitted entries include `id`, `path`, `tokens`, `directScore`, `score`. Confidence is `none`, `low`, `medium`, or `high` using maximum selected score thresholds 0, <0.34, <0.67, otherwise high.
 
 The hidden graph contains ties, cycles (propagation is still one hop), Unicode terms, required zero-score nodes, and candidates larger than the remaining budget.
+
+Run `npm test` when complete; it includes a fixed public happy-path contract for this scenario.

package/benchmarks/deep-logic-v1/prompts/fair-dependency-scheduler.md

@@ -11,3 +11,5 @@ Required invariants:
 - Never mutate the input. Every job appears exactly once, or the function throws.
 
 The hidden cases include dependencies that unlock across waves, weights that temporarily do not fit, punctuation in IDs, cycles, and three-tenant fairness. Add tests if useful.
+
+Run `npm test` when complete; it includes a fixed public happy-path contract for this scenario.

package/benchmarks/deep-logic-v1/prompts/layered-policy-resolution.md

@@ -12,3 +12,5 @@ Semantics:
 - Return `{ allowed, effect, layer, ruleIndex, protected, reason }` without exposing or changing inputs.
 
 Keep matching deterministic and do not use shell or filesystem glob expansion.
+
+Run `npm test` when complete; it includes a fixed public happy-path contract for this scenario.

package/benchmarks/deep-logic-v1/prompts/resumable-stream-assembly.md

@@ -7,7 +7,9 @@ Rules:
 - Do not mutate inputs. Validate safe non-negative integer cursors/offsets and well-formed strings.
 - Starting at `snapshot.cursor + 1`, consume only a contiguous cursor prefix. Report later events as `buffered`, ordered by cursor then arrival order, and return `gap` as `null` or `{ expected, observed }`.
 - Events at or below the snapshot cursor are replay and ignored. Conflicting duplicate cursors inside the provided event list throw; exact duplicates count once.
-- For each consumed event, `offset` must equal the current text length of its message. A completed message cannot receive more text. The event text is appended and `complete` is sticky.
+- For each consumed event, `offset` must equal the current JavaScript UTF-16 `String.length` of its message text. An empty final chunk may complete a message that is still open. Once a message is complete, any later event for it must throw, including an empty chunk. The event text is appended and `complete` is sticky.
 - Return `{ cursor, messages, appliedCursors, replayedCursors, buffered, gap }`. Preserve original message order and append newly seen messages in first-applied order.
 
 The hidden cases cover reconnect replay, interleaved messages, gaps, empty final chunks, surrogate-pair text length, and conflict rejection.
+
+Run `npm test` when complete; it includes a fixed public happy-path contract for this scenario.

package/benchmarks/deep-logic-v1/prompts/revision-event-reconciliation.md

@@ -12,3 +12,5 @@ Requirements:
 - Reject malformed objects, unsafe sequence numbers, non-string IDs/revisions, arrays as patches, and prototype-pollution keys (`__proto__`, `prototype`, `constructor`). Fail closed.
 
 Add focused tests if useful. Keep the implementation dependency-free and deterministic.
+
+Run `npm test` when complete; it includes a fixed public happy-path contract for this scenario.