@piagent/platform 1.5.1 → 1.5.3

package/benchmarks/capability-v1/references/causal-timeline-recovery/packages/timeline/src/checkpoint.js

@@ -0,0 +1,22 @@
+import crypto from "node:crypto";
+
+import { normalizeTimelineSnapshot } from "./project.js";
+
+function canonical(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean" || Number.isFinite(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(",")}}`;
+}
+function checksum(payload) { return crypto.createHash("sha256").update(canonical(payload)).digest("hex"); }
+
+export function encodeTimelineCheckpoint(state) {
+  const payload = normalizeTimelineSnapshot(state);
+  return JSON.stringify({ schemaVersion: 1, payload, checksum: checksum(payload) });
+}
+
+export function decodeTimelineCheckpoint(serialized) {
+  if (typeof serialized !== "string") throw new TypeError("checkpoint must be a string");
+  let value; try { value = JSON.parse(serialized); } catch { throw new TypeError("checkpoint must be JSON"); }
+  if (!value || value.schemaVersion !== 1 || !value.payload || value.checksum !== checksum(value.payload)) throw new TypeError("checkpoint integrity failure");
+  return normalizeTimelineSnapshot(value.payload);
+}

package/benchmarks/capability-v1/references/causal-timeline-recovery/packages/timeline/src/project.js

@@ -0,0 +1,77 @@
+import crypto from "node:crypto";
+
+function record(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${label} must be an object`);
+  return value;
+}
+function text(value, label) { if (typeof value !== "string" || !value.trim()) throw new TypeError(`${label} must be non-empty`); return value; }
+function integer(value, minimum, label) { if (!Number.isSafeInteger(value) || value < minimum) throw new TypeError(`${label} is invalid`); return value; }
+function eventDigest(event) {
+  return crypto.createHash("sha256").update(JSON.stringify({ id: event.id, cursor: event.cursor, messageId: event.messageId, offset: event.offset, text: event.text, complete: event.complete })).digest("hex");
+}
+
+export function normalizeTimelineSnapshot(snapshot) {
+  record(snapshot, "snapshot"); integer(snapshot.cursor, 0, "snapshot cursor");
+  if (!Array.isArray(snapshot.messages)) throw new TypeError("messages must be an array");
+  const ids = new Set();
+  const messages = snapshot.messages.map((message) => {
+    record(message, "message"); text(message.id, "message id");
+    if (ids.has(message.id) || typeof message.text !== "string" || typeof message.complete !== "boolean") throw new TypeError("invalid message");
+    ids.add(message.id); return { id: message.id, text: message.text, complete: message.complete };
+  });
+  record(snapshot.seen, "seen");
+  const seen = {};
+  for (const [id, digest] of Object.entries(snapshot.seen)) {
+    text(id, "seen id");
+    if (!/^[a-f0-9]{64}$/.test(digest)) throw new TypeError("invalid seen digest");
+    seen[id] = digest;
+  }
+  return { cursor: snapshot.cursor, messages, seen };
+}
+
+export function projectTimeline(snapshot, events, options = {}) {
+  const base = normalizeTimelineSnapshot(snapshot);
+  if (!Array.isArray(events) || !options || typeof options !== "object" || Array.isArray(options)) throw new TypeError("invalid projection input");
+  const maxChars = options.maxChars;
+  integer(maxChars, 0, "maxChars");
+  const uniqueById = new Map(); const digestByCursor = new Map(); const replayEvidence = new Set();
+  for (const event of events) {
+    record(event, "event"); text(event.id, "event id"); text(event.messageId, "message id");
+    integer(event.cursor, 1, "event cursor"); integer(event.offset, 0, "event offset");
+    if (typeof event.text !== "string" || typeof event.complete !== "boolean") throw new TypeError("invalid event payload");
+    const digest = eventDigest(event);
+    if (uniqueById.has(event.id)) {
+      if (uniqueById.get(event.id).digest !== digest) throw new TypeError("event id conflict");
+      replayEvidence.add(event.id); continue;
+    }
+    if (digestByCursor.has(event.cursor) && digestByCursor.get(event.cursor) !== digest) throw new TypeError("cursor conflict");
+    digestByCursor.set(event.cursor, digest); uniqueById.set(event.id, { event: { ...event }, digest });
+  }
+  const future = [];
+  for (const { event, digest } of uniqueById.values()) {
+    if (event.cursor <= base.cursor) {
+      if (base.seen[event.id] !== digest) throw new TypeError("unknown or conflicting historical event");
+      replayEvidence.add(event.id);
+    } else future.push({ event, digest });
+  }
+  future.sort((left, right) => left.event.cursor - right.event.cursor);
+  const messages = base.messages.map((item) => ({ ...item })); const byId = new Map(messages.map((item) => [item.id, item]));
+  const seen = { ...base.seen }; const appliedIds = []; let cursor = base.cursor;
+  let totalChars = messages.reduce((sum, item) => sum + item.text.length, 0); let gap = null; let backpressure = null; let stopIndex = future.length;
+  for (let index = 0; index < future.length; index += 1) {
+    const { event, digest } = future[index]; const expected = cursor + 1;
+    if (event.cursor !== expected) { gap = { expected, observed: event.cursor }; stopIndex = index; break; }
+    let message = byId.get(event.messageId);
+    const isNewMessage = !message;
+    if (!message) message = { id: event.messageId, text: "", complete: false };
+    if (message.complete || event.offset !== message.text.length) throw new TypeError("invalid message continuation");
+    const neededChars = totalChars + event.text.length;
+    if (neededChars > maxChars) { backpressure = { eventId: event.id, cursor: event.cursor, neededChars, maxChars }; stopIndex = index; break; }
+    if (isNewMessage) { messages.push(message); byId.set(event.messageId, message); }
+    message.text += event.text; message.complete = event.complete; totalChars = neededChars; cursor = event.cursor; seen[event.id] = digest; appliedIds.push(event.id);
+  }
+  return {
+    cursor, messages, seen, appliedIds, replayedIds: [...uniqueById.keys()].filter((id) => replayEvidence.has(id)),
+    buffered: future.slice(stopIndex).map(({ event }) => ({ ...event })), gap, backpressure
+  };
+}

package/benchmarks/capability-v1/references/durable-session-control-plane/apps/web/src/control-view.js

@@ -0,0 +1,4 @@
+export function controlSummary(receipt) {
+  if (!receipt || typeof receipt !== "object" || Array.isArray(receipt)) throw new TypeError("receipt must be an object");
+  return `kind=${receipt.kind}; command=${JSON.stringify(receipt.terminalCommand)}; revision=${receipt.revisionBefore}->${receipt.revisionAfter}; effect=${receipt.effect}; model=${receipt.expectedModelCalls}; replayed=${receipt.replayed}`;
+}

package/benchmarks/capability-v1/references/durable-session-control-plane/packages/session/src/admission.js

@@ -0,0 +1,52 @@
+import crypto from "node:crypto";
+
+import { routeRuntimeCommand } from "./runtime-route.js";
+
+function record(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${label} must be an object`);
+  return value;
+}
+
+function canonical(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (Number.isFinite(value)) return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (!value || typeof value !== "object") throw new TypeError("command payload is not canonical JSON");
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+}
+
+export function runtimeCommandDigest(input) {
+  record(input, "digest input");
+  if (Object.keys(input).length !== 2 || !Object.hasOwn(input, "kind") || !Object.hasOwn(input, "payload")) throw new TypeError("digest input must contain exactly kind and payload");
+  return crypto.createHash("sha256").update(canonical({ kind: input.kind, payload: input.payload })).digest("hex");
+}
+
+export function admitRuntimeCommand(state, input) {
+  record(state, "state"); record(input, "command");
+  if (!Number.isSafeInteger(state.revision) || state.revision < 0 || !record(state.receipts, "receipts")) throw new TypeError("invalid session state");
+  if (typeof input.idempotencyKey !== "string" || !input.idempotencyKey.trim() || ["__proto__", "prototype", "constructor"].includes(input.idempotencyKey)) throw new TypeError("invalid idempotency key");
+  const route = routeRuntimeCommand(input);
+  const commandDigest = runtimeCommandDigest({ kind: input.kind, payload: input.payload });
+  const prior = Object.hasOwn(state.receipts, input.idempotencyKey) ? state.receipts[input.idempotencyKey] : undefined;
+  if (prior) {
+    if (prior.commandDigest !== commandDigest) throw new TypeError("idempotency key conflict");
+    return { state, receipt: { ...prior, replayed: true } };
+  }
+  if (!Number.isSafeInteger(input.expectedRevision) || input.expectedRevision < 0 || input.expectedRevision !== state.revision) throw new TypeError("stale or invalid revision");
+  if (route.confirmationRequired && input.confirmed !== true) throw new TypeError("explicit confirmation required");
+  const revisionAfter = state.revision + 1;
+  if (!Number.isSafeInteger(revisionAfter)) throw new TypeError("revision overflow");
+  const stored = {
+    idempotencyKey: input.idempotencyKey,
+    commandDigest,
+    kind: input.kind,
+    terminalCommand: route.terminalCommand,
+    effect: route.effect,
+    expectedModelCalls: route.expectedModelCalls,
+    revisionBefore: state.revision,
+    revisionAfter,
+    replayed: false
+  };
+  const next = { revision: revisionAfter, receipts: { ...state.receipts, [input.idempotencyKey]: stored } };
+  return { state: next, receipt: { ...stored } };
+}

package/benchmarks/capability-v1/references/durable-session-control-plane/packages/session/src/runtime-route.js

@@ -0,0 +1,27 @@
+const KINDS = new Set(["status", "scout", "compact", "abort"]);
+
+function record(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${label} must be an object`);
+  return value;
+}
+
+function exactKeys(value, allowed, label) {
+  if (Object.keys(value).some((key) => !allowed.includes(key))) throw new TypeError(`${label} has unsupported fields`);
+}
+
+export function routeRuntimeCommand(input) {
+  record(input, "command");
+  exactKeys(input, ["idempotencyKey", "expectedRevision", "kind", "payload", "confirmed"], "command");
+  if (!KINDS.has(input.kind)) throw new TypeError("unknown runtime command kind");
+  const payload = record(input.payload, "payload");
+  if (input.kind === "scout") {
+    exactKeys(payload, ["objective"], "scout payload");
+    if (typeof payload.objective !== "string" || !payload.objective.trim()) throw new TypeError("scout objective must be non-empty");
+    const objective = payload.objective.trim().replace(/\s+/gu, " ");
+    return { terminalCommand: `/scout ${objective}`, confirmationRequired: true, expectedModelCalls: "bounded", effect: "model" };
+  }
+  exactKeys(payload, [], `${input.kind} payload`);
+  if (input.kind === "status") return { terminalCommand: "/status", confirmationRequired: false, expectedModelCalls: 0, effect: "read" };
+  if (input.kind === "compact") return { terminalCommand: "/compact", confirmationRequired: true, expectedModelCalls: "bounded", effect: "semantic" };
+  return { terminalCommand: "/abort", confirmationRequired: true, expectedModelCalls: 0, effect: "state" };
+}

package/benchmarks/capability-v1/rubric.json

@@ -55,6 +55,32 @@
       { "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 }
+    ],
+    "durable-session-control-plane": [
+      { "id": "runtime-route-validation", "clause": "D1", "critical": true, "weight": 2 },
+      { "id": "runtime-route-exact-contract", "clause": "D2", "critical": true, "weight": 2 },
+      { "id": "runtime-confirmation-authority", "clause": "D2", "critical": true, "weight": 2 },
+      { "id": "runtime-revision-validation", "clause": "D3", "critical": true, "weight": 2 },
+      { "id": "runtime-idempotent-replay", "clause": "D3", "critical": true, "weight": 2 },
+      { "id": "runtime-idempotency-conflict", "clause": "D3", "critical": true, "weight": 2 },
+      { "id": "runtime-digest-canonical", "clause": "D4", "critical": true, "weight": 2 },
+      { "id": "runtime-receipt-shape", "clause": "D5", "critical": true, "weight": 2 },
+      { "id": "runtime-state-isolation", "clause": "D5", "critical": true, "weight": 2 },
+      { "id": "runtime-control-summary", "clause": "D6", "critical": true, "weight": 2 }
+    ],
+    "causal-timeline-recovery": [
+      { "id": "timeline-snapshot-validation", "clause": "C1", "critical": true, "weight": 2 },
+      { "id": "timeline-event-validation", "clause": "C1", "critical": true, "weight": 2 },
+      { "id": "timeline-replay-and-conflicts", "clause": "C2", "critical": true, "weight": 2 },
+      { "id": "timeline-historical-validation", "clause": "C2", "critical": true, "weight": 2 },
+      { "id": "timeline-contiguous-gap", "clause": "C3", "critical": true, "weight": 2 },
+      { "id": "timeline-offset-completion", "clause": "C3", "critical": true, "weight": 2 },
+      { "id": "timeline-budget-boundary", "clause": "C4", "critical": true, "weight": 2 },
+      { "id": "timeline-input-isolation", "clause": "C4", "critical": true, "weight": 2 },
+      { "id": "timeline-checkpoint-roundtrip", "clause": "C5", "critical": true, "weight": 2 },
+      { "id": "timeline-checkpoint-tamper", "clause": "C5", "critical": true, "weight": 2 },
+      { "id": "timeline-render-exact", "clause": "C6", "critical": true, "weight": 2 },
+      { "id": "timeline-render-validation", "clause": "C6", "critical": true, "weight": 2 }
     ]
   }
 }

package/benchmarks/capability-v1/suite.json

@@ -1,19 +1,19 @@
 {
   "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.",
+  "title": "Piagent Public Capability V1 · Frontier Control-Plane Revision",
+  "description": "Six unsaturated multi-file capability tasks with issue-style repository work, run-private variants, comprehensive execution tests, and explicit atomic weighted rubrics; 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",
+    "taskSource": "maintainer-authored-multi-component-capability-archetypes-informed-by-swe-terminal-paper-re-tau-bench",
     "visibility": "public-suite-with-run-private-oracles",
     "claimTier": "capability",
     "generatedVariants": true,
     "familyDisjointSplit": false,
     "reviewed": true,
-    "refreshedAt": "2026-08-09"
+    "refreshedAt": "2026-08-20"
   },
   "releaseGate": {
     "minimumQualityScore": 8,
@@ -83,6 +83,34 @@
       "grader": "grade.mjs",
       "variantGenerator": "variant.mjs",
       "allowedChanges": ["packages/migration/src/**", "test/**"]
+    },
+    {
+      "id": "durable-session-control-plane",
+      "title": "Durable WebUI and Terminal session control plane",
+      "kind": "source-change",
+      "category": "operator-runtime",
+      "difficulty": "large",
+      "profile": "fullstack",
+      "lifecycle": "cold-start",
+      "fixture": "project",
+      "prompt": "prompts/durable-session-control-plane.md",
+      "grader": "grade.mjs",
+      "variantGenerator": "variant.mjs",
+      "allowedChanges": ["packages/session/src/**", "apps/web/src/control-view.js", "test/**"]
+    },
+    {
+      "id": "causal-timeline-recovery",
+      "title": "Causal reconnect timeline recovery and checkpoint integrity",
+      "kind": "source-change",
+      "category": "streaming",
+      "difficulty": "large",
+      "profile": "fullstack",
+      "lifecycle": "steady-state",
+      "fixture": "project",
+      "prompt": "prompts/causal-timeline-recovery.md",
+      "grader": "grade.mjs",
+      "variantGenerator": "variant.mjs",
+      "allowedChanges": ["packages/timeline/src/**", "apps/web/src/timeline-view.js", "test/**"]
     }
   ]
 }

package/benchmarks/capability-v1/variant.mjs

@@ -43,6 +43,17 @@ if (scenarioId === "multi-package-rollout") {
   oracle.graderData = {
     ids: [token("prepare"), token("transform"), token("finalize")]
   };
+} else if (scenarioId === "durable-session-control-plane") {
+  oracle.graderData = {
+    idempotencyKey: token("command"),
+    objective: `${token("inspect")} production   incident`
+  };
+} else if (scenarioId === "causal-timeline-recovery") {
+  oracle.graderData = {
+    messageA: token("message"), messageB: token("message"),
+    eventA: token("event"), eventB: token("event"), eventC: token("event"),
+    first: token("first"), second: token("second"), maxChars: integer(24, 48)
+  };
 } else throw new Error(`unsupported capability scenario ${scenarioId}`);
 
 fs.writeFileSync(oraclePath, `${JSON.stringify(oracle)}\n`, { mode: 0o600 });

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

@@ -0,0 +1,165 @@
+import assert from "node:assert/strict";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+const workspace = process.argv[2];
+const oracle = JSON.parse(fs.readFileSync(process.argv[3], "utf8"));
+const scenario = process.env.PIAGENT_BENCHMARK_SCENARIO;
+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); }
+
+switch (scenario) {
+  case "revision-event-reconciliation": {
+    const { reconcileSession } = await load("src/event-reconcile.js");
+    await check("contiguous-revision-application", () => {
+      const snapshot = { revision: data.revisions[0], nextSequence: data.start, state: { keep: true, remove: "old" } };
+      const first = { id: "a", sequence: data.start, baseRevision: data.revisions[0], revision: data.revisions[1], patch: { [data.key]: 1, remove: null } };
+      const second = { id: "b", sequence: data.start + 1, baseRevision: data.revisions[1], revision: data.revisions[2], patch: { [data.key]: 2 } };
+      const inputs = structuredClone([snapshot, [second, first, structuredClone(first)]]);
+      const result = reconcileSession(snapshot, [second, first, structuredClone(first)]);
+      assert.deepEqual(result, { revision: data.revisions[2], nextSequence: data.start + 2, state: { keep: true, [data.key]: 2 },
+        appliedIds: ["a", "b"], duplicateIds: ["a"], pending: [], gap: null });
+      assert.deepEqual([snapshot, [second, first, structuredClone(first)]], inputs);
+    });
+    await check("gap-and-conflict-fail-closed", () => {
+      const snapshot = { revision: "r0", nextSequence: 4, state: {} };
+      const late = { id: "late", sequence: 6, baseRevision: "r1", revision: "r2", patch: {} };
+      assert.deepEqual(reconcileSession(snapshot, [late]).gap, { expected: 4, observed: 6 });
+      assert.throws(() => reconcileSession(snapshot, [
+        { id: "x", sequence: 4, baseRevision: "r0", revision: "r1", patch: {} },
+        { id: "y", sequence: 4, baseRevision: "r0", revision: "r2", patch: {} }
+      ]));
+      assert.throws(() => reconcileSession(snapshot, [{ id: "x", sequence: 4, baseRevision: "wrong", revision: "r1", patch: {} }]));
+      assert.throws(() => reconcileSession(snapshot, [{ id: "x", sequence: 4, baseRevision: "r0", revision: "r1", patch: JSON.parse('{"__proto__":1}') }]));
+    });
+    break;
+  }
+  case "fair-dependency-scheduler": {
+    const { scheduleJobs } = await load("src/scheduler.js");
+    await check("dependency-capacity-fairness", () => {
+      const [a, b, c] = data.tenants, cap = data.capacity;
+      const jobs = [
+        { id: "a1", tenant: a, weight: 1, dependsOn: [] }, { id: "a2", tenant: a, weight: 1, dependsOn: [] },
+        { id: "b1", tenant: b, weight: 1, dependsOn: [] }, { id: "c1", tenant: c, weight: 1, dependsOn: [] },
+        { id: "after", tenant: a, weight: Math.min(2, cap), dependsOn: ["b1", "c1"] }
+      ];
+      const before = structuredClone(jobs), waves = scheduleJobs(jobs, cap);
+      assert.deepEqual(jobs, before);
+      assert.equal(new Set(waves.flat()).size, jobs.length);
+      assert.deepEqual(new Set(waves[0].slice(0, 3)), new Set(["a1", "b1", "c1"]));
+      const waveOf = new Map(waves.flatMap((wave, index) => wave.map((id) => [id, index])));
+      assert.ok(waveOf.get("after") > waveOf.get("b1") && waveOf.get("after") > waveOf.get("c1"));
+      for (const wave of waves) assert.ok(wave.reduce((sum, id) => sum + jobs.find((job) => job.id === id).weight, 0) <= cap);
+    });
+    await check("invalid-graph-rejected", () => {
+      assert.throws(() => scheduleJobs([{ id: "a", tenant: "t", weight: 1, dependsOn: ["b"] }], 2));
+      assert.throws(() => scheduleJobs([{ id: "a", tenant: "t", weight: 1, dependsOn: ["b"] }, { id: "b", tenant: "t", weight: 1, dependsOn: ["a"] }], 2));
+      assert.throws(() => scheduleJobs([{ id: "a", tenant: "t", weight: 3, dependsOn: [] }], 2));
+    });
+    break;
+  }
+  case "layered-policy-resolution": {
+    const { decideAccess } = await load("src/policy.js");
+    await check("precedence-and-protected-deny", () => {
+      const layers = [
+        { name: "global", rules: [{ pattern: "src/**", operations: [data.operation], effect: "allow" },
+          { pattern: "src/**", operations: [data.operation], effect: "deny" },
+          { pattern: "private/**", operations: ["*"], effect: "deny", protected: true }] },
+        { name: "project", rules: [{ pattern: "src/**", operations: [data.operation], effect: "allow" }] }
+      ];
+      assert.equal(decideAccess({ path: "src/a/config.json", operation: data.operation }, layers).allowed, true);
+      const denied = decideAccess({ path: data.protectedPath, operation: data.operation }, layers);
+      assert.equal(denied.allowed, false); assert.equal(denied.protected, true); assert.equal(denied.layer, "global");
+      assert.equal(decideAccess({ path: "docs/readme.md", operation: data.operation }, layers).allowed, false);
+    });
+    await check("path-and-rule-validation", () => {
+      const allow = [{ name: "x", rules: [{ pattern: "**", operations: ["*"], effect: "allow" }] }];
+      for (const unsafe of ["../secret", "/root", "a\\b", "a//b", "./a", "a/../b"]) assert.throws(() => decideAccess({ path: unsafe, operation: "read" }, allow));
+      assert.throws(() => decideAccess({ path: "a", operation: "read" }, [{ name: "x", rules: [{ pattern: "[a]", operations: ["read"], effect: "allow" }] }]));
+    });
+    break;
+  }
+  case "budgeted-context-graph": {
+    const { buildContextPack } = await load("src/context-pack.js");
+    await check("ranking-propagation-budget", () => {
+      const nodes = [
+        { id: "guide", path: "docs/guide.md", text: `${data.term} architecture`, tokens: 3 },
+        { id: "impl", path: "src/impl.js", text: "implementation details", tokens: 4 },
+        { id: "required", path: "AGENTS.md", text: "rules", tokens: 2, required: true },
+        { id: "large", path: "src/large.js", text: data.term, tokens: data.budget + 1 }
+      ];
+      const before = structuredClone(nodes), result = buildContextPack(data.term, nodes, [{ from: "guide", to: "impl", weight: 1 }], data.budget);
+      assert.deepEqual(nodes, before);
+      assert.deepEqual(result.selected.map((item) => item.id).slice(0, 3), ["required", "guide", "impl"]);
+      assert.ok(result.usedTokens <= data.budget); assert.equal(result.confidence, "high");
+      assert.equal(result.selected.find((item) => item.id === "impl").score, 0.5);
+      assert.ok(result.omitted.some((item) => item.id === "large"));
+    });
+    await check("graph-validation-and-required-budget", () => {
+      assert.throws(() => buildContextPack("x", [{ id: "a", path: "a", text: "x", tokens: 5, required: true }], [], 4));
+      assert.throws(() => buildContextPack("x", [{ id: "a", path: "a", text: "x", tokens: 1 }], [{ from: "a", to: "missing", weight: 1 }], 4));
+      const result = buildContextPack("Đặng", [{ id: "a", path: "a", text: "đặng", tokens: 1 }], [], 1);
+      assert.equal(result.selected[0].directScore, 1);
+    });
+    break;
+  }
+  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 }] };
+      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 }
+      ];
+      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);
+    });
+    await check("offset-completion-and-cursor-conflicts", () => {
+      const base = { cursor: 0, messages: [] };
+      assert.throws(() => assembleStream(base, [{ cursor: 1, messageId: "m", offset: 1, text: "x", complete: false }]));
+      assert.throws(() => assembleStream(base, [
+        { cursor: 1, messageId: "m", offset: 0, text: "x", complete: false },
+        { cursor: 1, messageId: "m", offset: 0, text: "y", complete: false }
+      ]));
+      assert.throws(() => assembleStream({ cursor: 0, messages: [{ id: "m", text: "x", complete: true }] },
+        [{ cursor: 1, messageId: "m", offset: 1, text: "", complete: true }]));
+    });
+    break;
+  }
+  case "transactional-config-merge": {
+    const { planConfigTransaction } = await load("src/config-transaction.js");
+    await check("merge-delete-default-audit-digest", () => {
+      const base = { service: { port: 3000, stale: true }, remove: "x" };
+      const layers = [{ service: { port: 0, [data.key]: data.value }, remove: { $delete: true } }];
+      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.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"));
+      assert.match(result.digest, /^[a-f0-9]{64}$/);
+      const canonical = JSON.stringify({ enabled: false, service: { [data.key]: data.value, port: 0, stale: true } });
+      assert.equal(result.digest, crypto.createHash("sha256").update(canonical).digest("hex"));
+    });
+    await check("schema-and-pollution-fail-closed", () => {
+      assert.throws(() => planConfigTransaction({}, [{ unknown: true }], { known: { type: "boolean" } }));
+      assert.throws(() => planConfigTransaction({}, [{}], { required: { type: "string", required: true } }));
+      assert.throws(() => planConfigTransaction({}, [{ x: { $delete: false } }], { x: { type: "object" } }));
+      assert.throws(() => planConfigTransaction(JSON.parse('{"__proto__":1}'), [], {}));
+    });
+    break;
+  }
+  default: throw new Error(`unsupported deep logic scenario ${scenario}`);
+}
+
+const passed = checks.length > 0 && checks.every((item) => item.passed);
+process.stdout.write(`${JSON.stringify({ passed, score: passed ? 10 : 0, checks })}\n`);

package/benchmarks/deep-logic-v1/project/README.md

@@ -0,0 +1,3 @@
+# Deep Logic Service
+
+Small dependency-free JavaScript modules used to exercise interacting invariants. Run `npm test` for the public smoke check; the benchmark uses additional run-private cases.

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

@@ -0,0 +1,6 @@
+{
+  "name": "piagent-deep-logic-fixture",
+  "private": true,
+  "type": "module",
+  "scripts": { "test": "node --test test/*.test.js" }
+}

package/benchmarks/deep-logic-v1/project/src/config-transaction.js

@@ -0,0 +1,3 @@
+export function planConfigTransaction(_base, _layers, _schema) {
+  throw new Error("not implemented");
+}

package/benchmarks/deep-logic-v1/project/src/context-pack.js

@@ -0,0 +1,3 @@
+export function buildContextPack(_query, _nodes, _edges, _budgetTokens) {
+  throw new Error("not implemented");
+}

package/benchmarks/deep-logic-v1/project/src/event-reconcile.js

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

package/benchmarks/deep-logic-v1/project/src/policy.js

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

package/benchmarks/deep-logic-v1/project/src/scheduler.js

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

package/benchmarks/deep-logic-v1/project/src/stream.js

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

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

@@ -0,0 +1,20 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+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";
+
+test("every benchmark entrypoint loads before private grading", () => {
+  for (const entrypoint of [
+    planConfigTransaction,
+    buildContextPack,
+    reconcileSession,
+    decideAccess,
+    scheduleJobs,
+    assembleStream
+  ]) assert.equal(typeof entrypoint, "function");
+});

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

@@ -0,0 +1,13 @@
+Implement `buildContextPack(query, nodes, edges, budgetTokens)` in `src/context-pack.js`.
+
+Nodes are `{ id, path, text, tokens, required? }`; directed edges are `{ from, to, weight }` with weight in `(0, 1]`.
+
+Required behavior:
+
+- Validate the graph, unique IDs, finite positive integer token costs, known endpoints, a positive integer budget, and plain inputs. Do not mutate inputs.
+- Tokenize the query and node text case-insensitively on Unicode non-letter/non-number boundaries. A node's direct score is the count of distinct query terms it contains divided by the number of distinct query terms.
+- Add one-hop propagation: for every directly scoring source, add `sourceDirectScore * edge.weight * 0.5` to its outgoing target. Cap final score at 1.
+- All `required` nodes must fit or the function throws. Select them first, then select positive-score nodes by descending final score, descending direct score, ascending tokens, then original node order, skipping candidates that do not fit. Never select a node twice.
+- 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.

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

@@ -0,0 +1,13 @@
+Implement `scheduleJobs(jobs, capacity)` in `src/scheduler.js`.
+
+Jobs are `{ id, tenant, weight, dependsOn }`. Return an array of waves, each an array of job IDs.
+
+Required invariants:
+
+- Validate a positive integer capacity, unique non-empty IDs, non-empty tenants, integer weights from 1 through capacity, existing dependencies, no self-dependency, and an acyclic graph.
+- A job may run only in a wave after every dependency completed in an earlier wave. A wave's total weight cannot exceed capacity.
+- Selection is deterministic and stable relative to input order within each selection pass. Order inside a returned wave records selection order: first include the fair-pass choice for every fitting tenant, then append stable fill-pass choices.
+- Tenant fairness: while another ready tenant with a job that fits is not represented in the current wave, do not give a represented tenant a second slot. After each ready tenant has had a fair opportunity, fill remaining capacity stably.
+- 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.

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

@@ -0,0 +1,14 @@
+Implement `decideAccess(request, layers)` in `src/policy.js`.
+
+`request` is `{ path, operation }`. `layers` is ordered from least to most authoritative; each is `{ name, rules }`. A rule is `{ pattern, operations, effect, protected? }`, where effect is `allow` or `deny`, and operations is a non-empty array of exact operation names or `*`.
+
+Semantics:
+
+- Accept only POSIX project-relative paths. Invalid requests, layers, rules, operations, and paths must throw before returning a decision. Unsafe paths include absolute paths, empty segments, `.`, `..`, backslashes, NUL, and paths outside the project.
+- Support glob segments `*` (one segment) and `**` (zero or more segments). A literal segment may contain only ASCII letters, digits, `.`, `_`, and `-`; reject embedded `*` and other glob syntax such as `[a]`, `?`, or `{a,b}`.
+- Within one layer, the last matching rule wins. A match in a more authoritative layer wins over a lower layer.
+- A matching `protected: true` deny is permanent and cannot be overridden by any later allow.
+- If nothing matches, deny. Invalid layers/rules fail closed by throwing.
+- Return `{ allowed, effect, layer, ruleIndex, protected, reason }` without exposing or changing inputs.
+
+Keep matching deterministic and do not use shell or filesystem glob expansion.

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

@@ -0,0 +1,13 @@
+Implement `assembleStream(snapshot, events)` in `src/stream.js`.
+
+The snapshot is `{ cursor, messages }`; each message is `{ id, text, complete }`. Events are `{ cursor, messageId, offset, text, complete }` and may arrive out of order or be replayed.
+
+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.
+- 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.

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

@@ -0,0 +1,14 @@
+Implement `reconcileSession(snapshot, events)` in `src/event-reconcile.js`.
+
+The snapshot is `{ revision, nextSequence, state }`. Each event is `{ id, sequence, baseRevision, revision, patch }`; `patch` is a plain object and a `null` value deletes that top-level key.
+
+Requirements:
+
+- Do not mutate any input.
+- Accept events in any order. Exact duplicate IDs with identical event content count once; the same ID with different content is an error.
+- Apply only the contiguous sequence beginning at `snapshot.nextSequence`. Stop before the first gap and return all later unique events in `pending`, ordered by sequence then original arrival order.
+- At a sequence, two non-identical events are a conflict and must throw. Before applying an event, its `baseRevision` must exactly equal the current revision; otherwise throw without returning a partial result.
+- Return `{ revision, nextSequence, state, appliedIds, duplicateIds, pending, gap }`. `gap` is `null` or `{ expected, observed }`.
+- 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.