@aiwg/cli 2026.8.26 → 2026.8.28

package/dist/src/storage/qualification.js

@@ -9,6 +9,10 @@ export async function qualifyStorageBackend(endpoint, options) {
     if (options.records.length !== options.scope.declaredRecords) {
         throw new Error('declared record scope does not match the qualification corpus');
     }
+    const readerCount = bounded(options.scope.readers, 1, 1, 32, 'readers');
+    if (options.scope.operations !== options.records.length + readerCount) {
+        throw new Error('declared operation scope must equal record writes plus concurrent readers');
+    }
     const now = options.now ?? (() => new Date());
     const startedAt = now().toISOString();
     const cpuBefore = process.cpuUsage();
@@ -21,7 +25,7 @@ export async function qualifyStorageBackend(endpoint, options) {
     const maxRetries = bounded(options.maxRetries, 5, 0, 20, 'maxRetries');
     const baseBackoffMs = bounded(options.baseBackoffMs, 2, 0, 60_000, 'baseBackoffMs');
     const batches = distribute(options.records, options.scope.writers);
-    await Promise.all(batches.map(async (records, writer) => {
+    const writes = Promise.all(batches.map(async (records, writer) => {
         for (const record of records) {
             const mutation = mutationFor(record, `qualification:${writer}:${record.identity.path}:${record.sourceRevision}`);
             const operationStart = performance.now();
@@ -48,19 +52,33 @@ export async function qualifyStorageBackend(endpoint, options) {
             sideEffects.push({ operation: `write:${record.identity.path}`, outcome: replayed ? 'replayed' : 'committed', batchId: receipt.batchId });
         }
     }));
+    const reads = Promise.all(Array.from({ length: readerCount }, async (_, reader) => {
+        const operationStart = performance.now();
+        try {
+            await endpoint.readAll();
+            latencies.push(performance.now() - operationStart);
+            sideEffects.push({ operation: `read:${reader}`, outcome: 'committed' });
+        }
+        catch (error) {
+            errors += 1;
+            sideEffects.push({ operation: `read:${reader}`, outcome: 'failed' });
+            throw error;
+        }
+    }));
+    await Promise.all([writes, reads]);
     const expectedDigest = digestRecords(options.records);
     const observed = [...await endpoint.readAll()];
     const verification = verifyExactRecords(options.records, observed);
     const durationMs = Math.max(performance.now() - start, 0.001);
     const cpu = process.cpuUsage(cpuBefore);
-    const supplied = options.resourceObservation?.() ?? {};
-    const operations = options.records.length + options.scope.readers;
+    const supplied = await options.resourceObservation?.() ?? {};
+    const operations = options.records.length + readerCount;
     const report = {
         schemaVersion: STORAGE_QUALIFICATION_REPORT,
         runId: createHash('sha256').update(`${options.scope.commit}\0${options.scope.backend}\0${startedAt}`).digest('hex'),
         startedAt,
         completedAt: now().toISOString(),
-        scope: { ...options.scope, observedRecords: observed.length },
+        scope: { ...options.scope, observedRecords: observed.length, observedOperations: sideEffects.length },
         verification: { ...verification, expectedDigest, observedDigest: digestRecords(observed) },
         latencyMs: percentiles(latencies),
         throughputPerSecond: operations / (durationMs / 1000),
@@ -71,7 +89,14 @@ export async function qualifyStorageBackend(endpoint, options) {
         resources: {
             cpuUserMicros: cpu.user, cpuSystemMicros: cpu.system,
             rssBytes: Math.max(process.memoryUsage().rss, rssBefore),
-            ...supplied,
+            databaseBytes: resourceMetric(supplied.databaseBytes, 'databaseBytes'),
+            writeAmplification: resourceMetric(supplied.writeAmplification, 'writeAmplification'),
+            walBytes: resourceMetric(supplied.walBytes, 'walBytes'),
+            lockWaits: resourceMetric(supplied.lockWaits, 'lockWaits'),
+            poolSaturation: resourceMetric(supplied.poolSaturation, 'poolSaturation'),
+            migrationMs: resourceMetric(supplied.migrationMs, 'migrationMs'),
+            recoveryMs: resourceMetric(supplied.recoveryMs, 'recoveryMs'),
+            transportOverheadMs: resourceMetric(supplied.transportOverheadMs, 'transportOverheadMs'),
         },
         sideEffects: sideEffects.sort((a, b) => a.operation.localeCompare(b.operation)),
     };
@@ -109,6 +134,8 @@ export function assertCurrentStorageEvidence(report, commit) {
         throw new Error('storage qualification record is stale for the requested commit');
     if (report.scope.declaredRecords !== report.scope.observedRecords)
         throw new Error('storage qualification scope is incomplete');
+    if (report.scope.operations !== report.scope.observedOperations)
+        throw new Error('storage qualification operation scope is incomplete');
 }
 function mutationFor(record, idempotencyKey) {
     return { operation: record.tombstone ? 'delete' : 'upsert', record, idempotencyKey };
@@ -134,4 +161,11 @@ function bounded(value, fallback, min, max, label) {
         throw new Error(`${label} must be an integer from ${min} through ${max}`);
     return resolved;
 }
+function resourceMetric(value, label) {
+    if (value === undefined || value === null)
+        return null;
+    if (!Number.isFinite(value) || value < 0)
+        throw new Error(`${label} must be a finite non-negative number`);
+    return value;
+}
 //# sourceMappingURL=qualification.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwg/cli",
-  "version": "2026.8.26",
+  "version": "2026.8.28",
   "description": "Lightweight AIWG CLI for signed, versioned web-backed resources.",
   "type": "module",
   "license": "MIT",