@llblab/pi-kit 0.29.1 → 0.30.0

package/node_modules/@llblab/pi-telegram/lib/workspace-slots.ts

@@ -40,8 +40,13 @@ function isValidSnapshot(
   const slots = new Set<string>();
   const keys = new Set<string>();
   for (const binding of bindings) {
-    if (!isSlot(binding.slot) || !binding.bindingKey ||
-        slots.has(binding.slot) || keys.has(binding.bindingKey)) return false;
+    if (
+      !isSlot(binding.slot) ||
+      !binding.bindingKey ||
+      slots.has(binding.slot) ||
+      keys.has(binding.bindingKey)
+    )
+      return false;
     slots.add(binding.slot);
     keys.add(binding.bindingKey);
   }
@@ -54,17 +59,21 @@ function eligibleByInactivity(
   nowMs: number,
 ): TelegramWorkspaceSlotOccupancy[] {
   const reserved = new Set(reservedSlots);
-  return bindings.filter((binding) =>
-    binding.protection === "eligible" &&
-    !reserved.has(binding.slot) &&
-    typeof binding.inactiveSinceMs === "number" &&
-    Number.isFinite(binding.inactiveSinceMs) &&
-    binding.inactiveSinceMs >= 0 &&
-    binding.inactiveSinceMs <= nowMs,
-  ).sort((left, right) =>
-    left.inactiveSinceMs! - right.inactiveSinceMs! ||
-    left.slot.charCodeAt(0) - right.slot.charCodeAt(0),
-  );
+  return bindings
+    .filter(
+      (binding) =>
+        binding.protection === "eligible" &&
+        !reserved.has(binding.slot) &&
+        typeof binding.inactiveSinceMs === "number" &&
+        Number.isFinite(binding.inactiveSinceMs) &&
+        binding.inactiveSinceMs >= 0 &&
+        binding.inactiveSinceMs <= nowMs,
+    )
+    .sort(
+      (left, right) =>
+        left.inactiveSinceMs! - right.inactiveSinceMs! ||
+        left.slot.charCodeAt(0) - right.slot.charCodeAt(0),
+    );
 }
 
 /** Caller must recheck exact ownership and protected work before retirement. */

package/node_modules/@llblab/pi-telegram/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.52.0",
+  "version": "0.53.0",
   "private": false,
   "publishConfig": {
     "access": "public"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-kit",
-  "version": "0.29.1",
+  "version": "0.30.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -46,8 +46,8 @@
     "@llblab/pi-clean-room": "0.3.0",
     "@llblab/pi-codex-usage": "0.12.1",
     "@llblab/pi-grow-loop": "0.9.0",
-    "@llblab/pi-state-flow": "0.26.1",
-    "@llblab/pi-telegram": "0.52.0",
+    "@llblab/pi-state-flow": "0.26.4",
+    "@llblab/pi-telegram": "0.53.0",
     "@llblab/skills": "1.15.0"
   },
   "bundledDependencies": [

package/node_modules/@llblab/pi-telegram/scripts/check-downgrade.mjs

@@ -1,472 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Conservative pre-downgrade journal authority check.
- * Usage: node scripts/check-downgrade.mjs [agent-dir]
- *
- * This is an intentionally simpler schema validator than `lib/journal.ts`.
- * It only needs to prove whether unresolved journal authority remains, so it
- * errs toward BLOCKED and does not cross-check the rules the runtime owns:
- *
- * - Operator dispositions are not reconciled against surviving entries
- *   (`lib/journal.ts` rejects a "discard" disposition whose entry is still
- *   present).
- * - `queueOwner` and `failure` are presence-checked, not deep-validated
- *   (acquisition shape, retry/terminal derivation, and disposition id
- *   generation stay in `lib/journal.ts`).
- *
- * The shared entry rules (keys, state enum, update_id agreement, and
- * queue/failure metadata presence) MUST stay in sync with
- * `lib/journal.ts` `validateJournalEntry`; `tests/journal-downgrade.test.ts`
- * reconciles the two surfaces on those rules.
- */
-
-import {
-  lstatSync,
-  readFileSync,
-  opendirSync,
-} from "node:fs";
-import { homedir } from "node:os";
-import { basename, join, resolve } from "node:path";
-import { decodeTelegramSessionDirectoryName, resolveTelegramTempDir } from "../dist/lib/paths.js";
-
-const MAX_DIRECTORY_ENTRIES = 10_000;
-const MAX_FILES = 4_096;
-const MAX_BYTES = 64 * 1024 * 1024;
-let remainingEntries = MAX_DIRECTORY_ENTRIES;
-let remainingFiles = MAX_FILES;
-let remainingBytes = MAX_BYTES;
-const SESSION_SNAPSHOT_PATTERN = /^(?:journal\.[a-f0-9]{16}|inbox)(?:\.[a-zA-Z0-9._-]+)?\.json$/u;
-const SNAPSHOT_PATTERN = /^(?:inbox|follower-inbox-[a-f0-9]{16})(?:\.[a-zA-Z0-9._-]+)?\.json$/u;
-const SEGMENT_NAME_PATTERN = /^\d{16}\.json$/u;
-const AUTHORITY_STATES = new Set(["pending", "retry-wait", "queued", "failed"]);
-const SNAPSHOT_KEYS = new Set([
-  "version",
-  "revision",
-  "profile",
-  "botIdentity",
-  "entries",
-  "operatorDispositions",
-]);
-const SEGMENT_KEYS = new Set([
-  "version",
-  "revision",
-  "previousRevision",
-  "profile",
-  "botIdentity",
-  "upsertedEntries",
-  "removedUpdateIds",
-  "operatorDispositions",
-]);
-const ENTRY_KEYS = new Set([
-  "updateId",
-  "update",
-  "admittedAtMs",
-  "state",
-  "queueKind",
-  "queueReceiptId",
-  "queueOwner",
-  "queueHandoff",
-  "failure",
-  "nextRetryAtMs",
-  "terminalAtMs",
-  "terminalReason",
-  "terminalFailureId",
-]);
-const DISPOSITION_KEYS = new Set([
-  "failureId",
-  "updateId",
-  "action",
-  "committedAtMs",
-  "attemptCount",
-  "failureClass",
-  "terminalAtMs",
-  "terminalReason",
-]);
-
-function resolveAgentDir() {
-  if (process.argv[2]) return resolve(process.argv[2]);
-  if (process.env.PI_CODING_AGENT_DIR) {
-    return resolve(process.env.PI_CODING_AGENT_DIR);
-  }
-  const executableName = basename(process.execPath).toLowerCase();
-  const invokedName = basename(process.argv[1] ?? "").toLowerCase();
-  return join(
-    homedir(),
-    executableName.startsWith("omp") || invokedName.startsWith("omp")
-      ? ".omp"
-      : ".pi",
-    "agent",
-  );
-}
-
-function block(message) {
-  console.error(`BLOCKED: ${message}`);
-  process.exitCode = 1;
-}
-
-function hasOnlyKeys(value, allowed) {
-  return Object.keys(value).every((key) => allowed.has(key));
-}
-
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function isPositiveInteger(value) {
-  return Number.isSafeInteger(value) && value > 0;
-}
-
-function isNonNegativeInteger(value) {
-  return Number.isSafeInteger(value) && value >= 0;
-}
-
-function listDirectory(path) {
-  const directory = opendirSync(path);
-  const names = [];
-  try {
-    for (;;) {
-      const entry = directory.readSync();
-      if (!entry) return names.sort();
-      if (--remainingEntries < 0) throw new Error("journal directory listing limit exhausted");
-      names.push(entry.name);
-    }
-  } finally { directory.closeSync(); }
-}
-
-function readJson(path, stat) {
-  try {
-    if (--remainingFiles < 0 || stat.size > remainingBytes)
-      throw new Error("journal file/byte inspection limit exhausted");
-    remainingBytes -= stat.size;
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch (error) {
-    block(
-      `cannot verify ${path}: ${error instanceof Error ? error.message : String(error)}`,
-    );
-    return undefined;
-  }
-}
-
-function validateBotIdentity(value) {
-  return (
-    isRecord(value) &&
-    hasOnlyKeys(value, new Set(["botId", "tokenSha256"])) &&
-    (value.botId === undefined || isPositiveInteger(value.botId)) &&
-    typeof value.tokenSha256 === "string" &&
-    /^[a-f0-9]{64}$/u.test(value.tokenSha256)
-  );
-}
-
-function identitiesMatch(left, right) {
-  if (
-    left.botId !== undefined &&
-    right.botId !== undefined &&
-    left.botId !== right.botId
-  ) {
-    return false;
-  }
-  return (
-    (left.botId !== undefined && left.botId === right.botId) ||
-    left.tokenSha256 === right.tokenSha256
-  );
-}
-
-function mergeBotIdentity(stored, current) {
-  return {
-    ...(current.botId !== undefined
-      ? { botId: current.botId }
-      : stored.botId !== undefined
-        ? { botId: stored.botId }
-        : {}),
-    tokenSha256: current.tokenSha256,
-  };
-}
-
-function validateEntries(value) {
-  if (!Array.isArray(value)) return undefined;
-  const entries = new Map();
-  let previousId = -1;
-  for (const entry of value) {
-    if (
-      !isRecord(entry) ||
-      !hasOnlyKeys(entry, ENTRY_KEYS) ||
-      !isNonNegativeInteger(entry.updateId) ||
-      entry.updateId <= previousId ||
-      !AUTHORITY_STATES.has(entry.state) ||
-      !isRecord(entry.update) ||
-      entry.update.update_id !== entry.updateId ||
-      !isNonNegativeInteger(entry.admittedAtMs)
-    ) {
-      return undefined;
-    }
-    const hasQueueMetadata =
-      entry.queueKind !== undefined ||
-      entry.queueReceiptId !== undefined ||
-      entry.queueOwner !== undefined ||
-      entry.queueHandoff !== undefined;
-    const hasFailureMetadata =
-      entry.failure !== undefined ||
-      entry.nextRetryAtMs !== undefined ||
-      entry.terminalAtMs !== undefined ||
-      entry.terminalReason !== undefined ||
-      entry.terminalFailureId !== undefined;
-    if (
-      (entry.state === "pending" && (hasQueueMetadata || hasFailureMetadata)) ||
-      (entry.state === "queued" &&
-        ((entry.queueKind !== "prompt" && entry.queueKind !== "control") ||
-          typeof entry.queueReceiptId !== "string" ||
-          entry.queueReceiptId.length === 0 ||
-          entry.queueOwner === undefined ||
-          hasFailureMetadata)) ||
-      ((entry.state === "retry-wait" || entry.state === "failed") &&
-        (hasQueueMetadata || !isRecord(entry.failure)))
-    ) {
-      return undefined;
-    }
-    previousId = entry.updateId;
-    entries.set(entry.updateId, entry);
-  }
-  return entries;
-}
-
-function validateOperatorDispositions(value) {
-  if (value === undefined) return true;
-  if (!Array.isArray(value)) return false;
-  const failureIds = new Set();
-  for (const disposition of value) {
-    if (
-      !isRecord(disposition) ||
-      !hasOnlyKeys(disposition, DISPOSITION_KEYS) ||
-      typeof disposition.failureId !== "string" ||
-      disposition.failureId.length === 0 ||
-      failureIds.has(disposition.failureId) ||
-      !isNonNegativeInteger(disposition.updateId) ||
-      (disposition.action !== "retry" && disposition.action !== "discard") ||
-      !isNonNegativeInteger(disposition.committedAtMs) ||
-      !isPositiveInteger(disposition.attemptCount) ||
-      typeof disposition.failureClass !== "string" ||
-      disposition.failureClass.length === 0 ||
-      !isNonNegativeInteger(disposition.terminalAtMs) ||
-      disposition.committedAtMs < disposition.terminalAtMs ||
-      typeof disposition.terminalReason !== "string" ||
-      disposition.terminalReason.length === 0
-    ) {
-      return false;
-    }
-    failureIds.add(disposition.failureId);
-  }
-  return true;
-}
-
-function validateSnapshot(value) {
-  if (
-    !isRecord(value) ||
-    !hasOnlyKeys(value, SNAPSHOT_KEYS) ||
-    value.version !== 1 ||
-    (value.revision !== undefined && !isPositiveInteger(value.revision)) ||
-    typeof value.profile !== "string" ||
-    value.profile.length === 0 ||
-    !validateBotIdentity(value.botIdentity) ||
-    !validateOperatorDispositions(value.operatorDispositions)
-  ) {
-    return undefined;
-  }
-  const entries = validateEntries(value.entries);
-  if (!entries) return undefined;
-  return {
-    revision: value.revision ?? 0,
-    profile: value.profile,
-    botIdentity: value.botIdentity,
-    entries,
-  };
-}
-
-function validateSegment(value) {
-  if (
-    !isRecord(value) ||
-    !hasOnlyKeys(value, SEGMENT_KEYS) ||
-    value.version !== 1 ||
-    !isPositiveInteger(value.revision) ||
-    !isNonNegativeInteger(value.previousRevision) ||
-    value.previousRevision !== value.revision - 1 ||
-    typeof value.profile !== "string" ||
-    value.profile.length === 0 ||
-    !validateBotIdentity(value.botIdentity) ||
-    !Array.isArray(value.upsertedEntries) ||
-    !Array.isArray(value.removedUpdateIds) ||
-    !validateOperatorDispositions(value.operatorDispositions)
-  ) {
-    return undefined;
-  }
-  const upsertedEntries = validateEntries(
-    [...value.upsertedEntries].sort((left, right) =>
-      Number(left?.updateId) - Number(right?.updateId),
-    ),
-  );
-  if (!upsertedEntries || upsertedEntries.size !== value.upsertedEntries.length) {
-    return undefined;
-  }
-  const removedUpdateIds = new Set();
-  for (const updateId of value.removedUpdateIds) {
-    if (
-      !isNonNegativeInteger(updateId) ||
-      removedUpdateIds.has(updateId) ||
-      upsertedEntries.has(updateId)
-    ) {
-      return undefined;
-    }
-    removedUpdateIds.add(updateId);
-  }
-  return {
-    revision: value.revision,
-    previousRevision: value.previousRevision,
-    profile: value.profile,
-    botIdentity: value.botIdentity,
-    upsertedEntries,
-    removedUpdateIds,
-  };
-}
-
-const agentDir = resolveAgentDir();
-const runtimeDir = resolveTelegramTempDir(agentDir);
-let runtimeNames;
-let observedRuntime = false;
-try {
-  if (!lstatSync(runtimeDir).isDirectory()) throw new Error("non-directory Telegram runtime or link");
-  observedRuntime = true;
-  runtimeNames = listDirectory(runtimeDir);
-} catch (error) {
-  if (error?.code === "ENOENT" && !observedRuntime) {
-    console.log("SAFE: no Telegram runtime directory exists.");
-    process.exit(0);
-  }
-  block(`cannot verify Telegram runtime directory ${runtimeDir}: ${error instanceof Error ? error.message : String(error)}`);
-  process.exit(1);
-}
-
-function collectSnapshots(directory, names, pattern, strict = false) {
-  const snapshots = names.filter(name => pattern.test(name));
-  const snapshotSet = new Set(snapshots);
-  for (const name of names) {
-    // Legacy recovery folders hold no journal authority; current releases delete them.
-    if (name.toLowerCase() === "recovery") continue;
-    const snapshotName = name.endsWith(".segments") ? name.slice(0, -".segments".length) : undefined;
-    if (snapshotName && pattern.test(snapshotName)) {
-      if (!snapshotSet.has(snapshotName)) block(`cannot verify orphan journal segments without ${join(directory, snapshotName)}`);
-      continue;
-    }
-    if (!pattern.test(name) && (strict || /^(?:inbox|follower-inbox|journal\.)/iu.test(name)))
-      block(`cannot verify unrecognized journal-like artifact ${join(directory, name)}`);
-  }
-  return snapshots.map(name => join(directory, name));
-}
-
-const snapshotPaths = collectSnapshots(runtimeDir, runtimeNames, SNAPSHOT_PATTERN);
-for (const name of runtimeNames.filter(name => name.toLowerCase() === "sessions")) {
-  const root = join(runtimeDir, name);
-  try {
-    if (name !== "sessions" || !lstatSync(root).isDirectory()) throw new Error("noncanonical session root or link/type");
-    for (const sessionName of listDirectory(root)) {
-      const directory = join(root, sessionName);
-      if (decodeTelegramSessionDirectoryName(sessionName) === undefined || !lstatSync(directory).isDirectory()) {
-        block(`cannot verify session folder ${directory}`);
-        continue;
-      }
-      snapshotPaths.push(...collectSnapshots(directory, listDirectory(directory), SESSION_SNAPSHOT_PATTERN, true));
-    }
-  } catch (error) { block(`cannot verify session journals ${root}: ${String(error)}`); }
-}
-
-for (const path of snapshotPaths) {
-  let pathStat;
-  try {
-    pathStat = lstatSync(path);
-  } catch (error) {
-    block(`cannot verify journal snapshot ${path}: ${String(error)}`);
-    continue;
-  }
-  if (!pathStat.isFile()) {
-    block(`cannot verify non-file journal snapshot ${path}`);
-    continue;
-  }
-  const snapshot = validateSnapshot(readJson(path, pathStat));
-  if (!snapshot) {
-    block(`cannot verify malformed journal snapshot ${path}`);
-    continue;
-  }
-
-  let revision = snapshot.revision;
-  let botIdentity = snapshot.botIdentity;
-  const entries = snapshot.entries;
-  const segmentDir = `${path}.segments`;
-  let segmentDirectoryStat;
-  try { segmentDirectoryStat = lstatSync(segmentDir); }
-  catch (error) {
-    if (error?.code !== "ENOENT") block(`cannot verify journal segments ${segmentDir}: ${String(error)}`);
-  }
-  if (segmentDirectoryStat) {
-    let segmentNames;
-    try {
-      if (!segmentDirectoryStat.isDirectory()) {
-        block(`cannot verify non-directory journal segments ${segmentDir}`);
-        continue;
-      }
-      segmentNames = listDirectory(segmentDir);
-    } catch (error) {
-      block(`cannot verify journal segments ${segmentDir}: ${String(error)}`);
-      continue;
-    }
-    const unrecognized = segmentNames.filter(
-      (segmentName) => !SEGMENT_NAME_PATTERN.test(segmentName),
-    );
-    for (const segmentName of unrecognized) {
-      block(`cannot verify unrecognized journal segment ${join(segmentDir, segmentName)}`);
-    }
-    for (const segmentName of segmentNames.filter((candidate) =>
-      SEGMENT_NAME_PATTERN.test(candidate),
-    ).sort()) {
-      const nameRevision = Number(segmentName.slice(0, 16));
-      const segmentPath = join(segmentDir, segmentName);
-      let segmentStat;
-      try {
-        segmentStat = lstatSync(segmentPath);
-      } catch (error) {
-        block(`cannot verify journal segment ${segmentPath}: ${String(error)}`);
-        break;
-      }
-      if (!segmentStat.isFile()) { block(`cannot verify non-file journal segment ${segmentPath}`); break; }
-      if (nameRevision <= revision) continue;
-      const segment = validateSegment(readJson(segmentPath, segmentStat));
-      if (
-        !segment ||
-        segment.revision !== nameRevision ||
-        segment.previousRevision !== revision
-      ) {
-        block(`cannot verify malformed or gapped journal segment ${segmentPath}`);
-        break;
-      }
-      if (
-        segment.profile !== snapshot.profile ||
-        !identitiesMatch(segment.botIdentity, botIdentity)
-      ) {
-        block(`cannot verify foreign journal segment identity ${segmentPath}`);
-        break;
-      }
-      for (const updateId of segment.removedUpdateIds) entries.delete(updateId);
-      for (const [updateId, entry] of segment.upsertedEntries) {
-        entries.set(updateId, entry);
-      }
-      revision = segment.revision;
-      botIdentity = mergeBotIdentity(botIdentity, segment.botIdentity);
-    }
-  }
-  if (entries.size > 0) {
-    block(
-      `${path} retains ${entries.size} unresolved update(s); drain with a compatible runtime before downgrade.`,
-    );
-  }
-}
-
-if (process.exitCode) process.exit(1);
-console.log(`SAFE: ${snapshotPaths.length} Telegram journal(s) contain no unresolved updates.`);

package/node_modules/@llblab/pi-telegram/scripts/measure-workspace.mjs

@@ -1,108 +0,0 @@
-/**
- * Measures isolated Thread-store filesystem work at representative sizes.
- * Usage: node --experimental-strip-types scripts/measure-workspace.mjs
- *
- * This assertion-backed fixture uses and removes its own temporary directory.
- * It never reads configured profiles, calls Telegram, or measures latency.
- */
-
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import { syncBuiltinESMExports } from "node:module";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createTelegramTopicTargetStore } from "../lib/threads.ts";
-
-const repetitions = 10;
-const original = { readFile: fs.readFile, writeFile: fs.writeFile, mkdir: fs.mkdir, rename: fs.rename,
-  parse: JSON.parse, stringify: JSON.stringify };
-let counts;
-const rows = [];
-const root = await fs.mkdtemp(join(tmpdir(), "pi-telegram-measure-workspace-"));
-
-async function measure(size, operation, execute, samples = repetitions) {
-  counts = { reads: 0, readBytes: 0, writes: 0, writeBytes: 0, mkdirs: 0, renames: 0,
-    parses: 0, stringifies: 0 };
-  try {
-    for (let index = 0; index < samples; index++) await execute(index);
-    const result = { size, operation, repetitions: samples, ...counts };
-    rows.push(result);
-    return result;
-  } finally {
-    counts = undefined;
-  }
-}
-
-try {
-  fs.readFile = async (...args) => {
-    if (counts) counts.reads++;
-    const result = await original.readFile(...args);
-    if (counts) counts.readBytes += Buffer.byteLength(result);
-    return result;
-  };
-  fs.writeFile = async (...args) => {
-    if (counts) { counts.writes++; counts.writeBytes += Buffer.byteLength(args[1]); }
-    return original.writeFile(...args);
-  };
-  fs.mkdir = async (...args) => {
-    if (counts) counts.mkdirs++;
-    return original.mkdir(...args);
-  };
-  fs.rename = async (...args) => {
-    if (counts) counts.renames++;
-    return original.rename(...args);
-  };
-  JSON.parse = (...args) => { if (counts) counts.parses++; return original.parse(...args); };
-  JSON.stringify = (...args) => { if (counts) counts.stringifies++; return original.stringify(...args); };
-  syncBuiltinESMExports();
-
-  for (const size of [1, 13, 26]) {
-    const path = join(root, `${size}.json`);
-    const store = createTelegramTopicTargetStore({ path, getNowMs: () => 1000 });
-    for (let index = 0; index < size; index++) {
-      const instanceId = `fixture-${index}`;
-      const identity = store.claimWorkspaceIdentity(`/fixture/${index}`, instanceId);
-      assert.ok(identity);
-      const target = { chatId: 7, threadId: index + 1 };
-      assert.ok(store.upsertWorkspaceBinding({ ...identity, target, updatedAtMs: 1000 }, instanceId));
-      store.upsert({ profileKey: `manual:${instanceId}`, instanceId, slot: identity.slot,
-        target, status: "active", createdAtMs: 1000, updatedAtMs: 1000 });
-    }
-    await store.persist();
-    assert.equal(new Set(store.listWorkspaceBindings().map((entry) => entry.slot)).size, size);
-    await measure(size, "cold-load", async () => {
-      const reader = createTelegramTopicTargetStore({ path });
-      await reader.load();
-      assert.equal(reader.list().length, size);
-      assert.equal(reader.listWorkspaceBindings().length, size);
-    });
-    const lookup = await measure(size, "lookup-last", () => {
-      assert.equal(store.getByProfileKey(`manual:fixture-${size - 1}`)?.target.threadId, size);
-    });
-    assert.equal(lookup.reads + lookup.writes, 0);
-    const beforeReloadSave = JSON.parse(await fs.readFile(path, "utf8"));
-    const reloaded = await measure(size, "first-persist-after-reload", () => store.persist(), 1);
-    assert.equal(reloaded.writes + reloaded.renames + reloaded.mkdirs, 0);
-    assert.deepEqual(JSON.parse(await fs.readFile(path, "utf8")), beforeReloadSave,
-      "The first reloaded save must preserve the seeded semantic state");
-    const unchanged = await measure(size, "unchanged-persist", () => store.persist());
-    assert.equal(unchanged.writes + unchanged.renames + unchanged.mkdirs, 0);
-    assert.ok(unchanged.reads >= repetitions, "No-op saves still consult disk authority");
-    const changed = await measure(size, "diagnostic-persist", async (index) => {
-      store.setStatusSnapshot({ diagnostics: { measurementStep: index } });
-      await store.persist();
-    });
-    assert.equal(changed.writes, repetitions);
-    assert.equal(changed.renames, repetitions);
-  }
-} finally {
-  Object.assign(fs, { readFile: original.readFile, writeFile: original.writeFile,
-    mkdir: original.mkdir, rename: original.rename });
-  JSON.parse = original.parse;
-  JSON.stringify = original.stringify;
-  syncBuiltinESMExports();
-  await fs.rm(root, { recursive: true, force: true });
-}
-console.log(JSON.stringify({ scope: "Isolated Thread store, not IPC/admission/Telegram or throughput",
-  counters: "Aggregate API calls and bytes for each row's repetitions; object-spread clones are not instrumented",
-  rows }, null, 2));