@aiwg/cli 2026.9.0 → 2026.9.2

package/dist/src/sessions/adapters/pi.js

@@ -0,0 +1,141 @@
+import { opendir } from 'node:fs/promises';
+import { basename, resolve } from 'node:path';
+import { z } from 'zod';
+import { SessionContractError, } from '../contracts.js';
+import { readBoundedJsonLines, streamBoundedJsonLines } from '../readers.js';
+export const PI_ADAPTER_VERSION = '1.0.0';
+export const PI_SOURCE_SCHEMA_VERSION = '3.0.0';
+const Header = z.object({ type: z.literal('session'), version: z.number().int(), id: z.string().min(1),
+    timestamp: z.string().datetime({ offset: true }), cwd: z.string(), parentSession: z.string().optional() }).passthrough();
+const Entry = z.object({ type: z.string().min(1), id: z.string().min(1),
+    parentId: z.string().nullable(), timestamp: z.string().datetime({ offset: true }) }).passthrough();
+export class PiSessionAdapter {
+    limits;
+    maxFiles;
+    provider = 'pi';
+    adapterVersion = PI_ADAPTER_VERSION;
+    disposition = 'implemented';
+    supportedOperations = ['discover', 'inspect', 'stream'];
+    acquisitionModes = ['jsonl'];
+    constructor(limits, maxFiles = 10_000) {
+        this.limits = limits;
+        this.maxFiles = maxFiles;
+    }
+    async *discover(scope) {
+        if (!scope.allowedRoots.length)
+            throw new SessionContractError('SOURCE_NOT_AUTHORIZED', 'Pi discovery requires an authorized sessions root');
+        let count = 0;
+        for (const root of [...scope.allowedRoots].sort()) {
+            for await (const locator of jsonlFiles(resolve(root))) {
+                if (++count > this.maxFiles)
+                    throw new SessionContractError('RESOURCE_LIMIT_EXCEEDED', 'Pi discovery file limit exceeded');
+                yield { provider: 'pi', locator, locatorClass: 'pi-session-v3-jsonl' };
+            }
+        }
+    }
+    async inspect(source) {
+        let input;
+        try {
+            input = await readBoundedJsonLines({ selectedPath: source.locator,
+                allowedRoots: source.authorizedScope.allowedRoots }, { consistency: 'provisional', limits: this.limits });
+        }
+        catch (error) {
+            throw normalizeAuthorizationError(error);
+        }
+        const header = parseHeader(input.records[0]?.value);
+        if (input.incompleteTail)
+            throw new SessionContractError('TRUNCATED_SOURCE', 'Pi session has a truncated JSONL tail');
+        return { sourceSchemaVersion: `${header.version}.0.0`, consistency: 'complete', operationalState: 'available' };
+    }
+    async *stream(source, cursor) {
+        let input;
+        try {
+            input = await streamBoundedJsonLines({ selectedPath: source.locator,
+                allowedRoots: source.authorizedScope.allowedRoots }, { cursor: cursor?.value, consistency: 'provisional', limits: this.limits });
+        }
+        catch (error) {
+            throw normalizeAuthorizationError(error);
+        }
+        let sessionId = '';
+        let index = 0;
+        const ids = new Set();
+        for await (const line of input) {
+            if (index++ === 0 && !cursor) {
+                sessionId = parseHeader(line.value).id;
+                continue;
+            }
+            if (!sessionId)
+                sessionId = basename(source.locator, '.jsonl');
+            const parsed = Entry.safeParse(line.value);
+            if (!parsed.success)
+                throw new SessionContractError('MALFORMED_SOURCE', 'Pi session entry is malformed');
+            const entry = parsed.data;
+            if (ids.has(entry.id))
+                throw new SessionContractError('DUPLICATE_NATIVE_ID', 'Pi session contains a duplicate entry id');
+            ids.add(entry.id);
+            const message = object(entry.message);
+            const role = string(message.role) ?? roleFor(entry.type);
+            const sensitive = role === 'toolResult' || entry.type === 'custom';
+            const text = sensitive ? '[redacted provider content]' : entryText(entry, message);
+            yield { nativeSessionId: sessionId, nativeEventId: entry.id, sequence: line.sequence,
+                kind: kindFor(entry.type, role), role, toolName: sensitive ? string(message.toolName) : undefined,
+                toolCallId: sensitive ? string(message.toolCallId) : undefined,
+                occurredAt: entry.timestamp, text, sourceCursor: String(line.byteOffset + line.byteLength),
+                sourceBytes: line.byteLength, rawReference: { locatorClass: 'pi-session-v3-jsonl', offset: line.byteOffset },
+                activityBoundary: entry.type === 'compaction' ? 'continuation' : undefined,
+                activityBoundaryBasis: entry.type === 'compaction' ? 'pi-session:compaction' : undefined,
+                activityBoundaryConfidence: entry.type === 'compaction' ? 'high' : undefined,
+                extensions: { provenance: { acquisition: 'pi-session-v3', parentId: entry.parentId },
+                    opaque: !KNOWN.has(entry.type), redacted: sensitive,
+                    nativeType: entry.type, parentId: entry.parentId } };
+        }
+        if (input.incompleteTail)
+            throw new SessionContractError('TRUNCATED_SOURCE', 'Pi session has a truncated JSONL tail');
+    }
+}
+const KNOWN = new Set(['message', 'thinking_level_change', 'model_change', 'compaction',
+    'branch_summary', 'custom', 'label', 'session_info', 'custom_message']);
+function parseHeader(value) {
+    const parsed = Header.safeParse(value);
+    if (!parsed.success)
+        throw new SessionContractError('MALFORMED_SOURCE', 'Pi session header is malformed');
+    if (parsed.data.version !== 3)
+        throw new SessionContractError('UNKNOWN_SCHEMA_MAJOR', `unsupported Pi session version: ${parsed.data.version}`);
+    return parsed.data;
+}
+function object(value) { return value && typeof value === 'object' ? value : {}; }
+function string(value) { return typeof value === 'string' && value ? value : undefined; }
+function roleFor(type) { return type === 'compaction' || type === 'branch_summary' ? 'system' : undefined; }
+function kindFor(type, role) { return type === 'message' ? `message.${role ?? 'unknown'}` : `pi.${type}`; }
+function entryText(entry, message) {
+    const value = entry.type === 'message' ? message.content : entry.summary ?? entry.name ?? entry.label ?? '';
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value))
+        return value.flatMap(part => typeof part === 'string' ? part : string(object(part).text) ?? []).join('\n');
+    return '';
+}
+async function* jsonlFiles(root) {
+    let directory;
+    try {
+        directory = await opendir(root);
+    }
+    catch {
+        return;
+    }
+    for await (const entry of directory) {
+        const path = resolve(root, entry.name);
+        if (entry.isDirectory())
+            yield* jsonlFiles(path);
+        else if (entry.isFile() && entry.name.endsWith('.jsonl'))
+            yield path;
+    }
+}
+function normalizeAuthorizationError(error) {
+    if (error instanceof SessionContractError && (error.code === 'SOURCE_OUTSIDE_ALLOWED_ROOT'
+        || error.code === 'SOURCE_SYMLINK' || error.code === 'SOURCE_NOT_REGULAR_FILE')) {
+        return new SessionContractError('SOURCE_NOT_AUTHORIZED', 'Pi source is not an authorized regular file');
+    }
+    return error;
+}
+//# sourceMappingURL=pi.js.map

package/dist/src/sessions/contracts.js

@@ -3,7 +3,7 @@ import { z } from 'zod';
 export const SESSION_CONTRACT_VERSION = '1.0.0';
 export const SESSION_PROVIDER_IDS = [
     'claude', 'codex', 'copilot', 'cursor', 'factory', 'hermes',
-    'opencode', 'openclaw', 'openhuman', 'warp', 'devin-desktop', 'generic',
+    'opencode', 'openclaw', 'openhuman', 'pi', 'warp', 'devin-desktop', 'generic',
 ];
 export const SessionProviderIdSchema = z.enum(SESSION_PROVIDER_IDS);
 export const SESSION_PROVIDER_ALIASES = Object.freeze({

package/dist/src/sessions/index.js

@@ -28,6 +28,7 @@ export * from './adapters/hermes.js';
 export * from './adapters/opencode.js';
 export * from './adapters/openclaw.js';
 export * from './adapters/openhuman.js';
+export * from './adapters/pi.js';
 export * from './adapters/warp.js';
 export * from './adapters/windsurf.js';
 //# sourceMappingURL=index.js.map

package/dist/src/sessions/workspace-discovery.js

@@ -7,6 +7,7 @@ import { ClaudeSessionAdapter } from './adapters/claude.js';
 import { CodexSessionAdapter } from './adapters/codex.js';
 import { CursorSessionAdapter } from './adapters/cursor.js';
 import { FactorySessionAdapter } from './adapters/factory.js';
+import { PiSessionAdapter } from './adapters/pi.js';
 import { SESSION_PROVIDER_IDS, sha256, } from './contracts.js';
 import { redactSourceLocator } from './discovery.js';
 import { fingerprintSourceFile } from './readers.js';
@@ -49,6 +50,15 @@ export async function discoverWorkspaceHistories(options) {
                 join(providerHome, '.factory', 'sessions', keyWithLeadingDash),
             ]),
         },
+        {
+            provider: 'pi',
+            adapter: new PiSessionAdapter(),
+            roots: options.providerHome
+                ? [process.env.PI_CODING_AGENT_SESSION_DIR
+                        ? resolve(process.env.PI_CODING_AGENT_SESSION_DIR)
+                        : join(resolve(options.providerHome), '.pi', 'agent', 'sessions')]
+                : [],
+        },
     ];
     const reports = new Map();
     const candidates = [];

package/dist/src/storage/backends/fortemi.js

@@ -301,6 +301,12 @@ export const createDefaultMcpClient = async (serverName, registryOverride, envir
         async callTool(name, args) {
             return unwrapMcpToolResult(await client.callTool({ name, arguments: args }));
         },
+        async listTools() {
+            return client.listTools();
+        },
+        serverVersion() {
+            return client.getServerVersion();
+        },
         async close() {
             await client.close();
         },

package/dist/src/storage/config.js

@@ -5,10 +5,9 @@
  * v1 schema, and returns a typed `StorageConfig`. Absence of the file is
  * a no-op: every subsystem defaults to `fs` rooted under `.aiwg/`.
  *
- * Validation is hand-rolled rather than schema-validator-driven to avoid
- * adding an `ajv` dependency for a single file. The published JSON
- * Schema (`.aiwg/architecture/schemas/storage.config.v1.json`) remains
- * canonical for editor tooling and external consumers.
+ * Runtime validation is kept in parity with the canonical JSON Schema at
+ * `schemas/storage/storage.config.v1.schema.json`; the lightweight path here
+ * avoids loading the full catalog during storage bootstrap.
  *
  * @design @.aiwg/architecture/storage-design.md
  * @issue #934
@@ -98,6 +97,7 @@ export function validateStorageConfig(parsed, source = '<input>') {
             `(expected "1"). Update the AIWG CLI to read newer config versions.`);
     }
     walkRejectingCredentials(obj, source, 'storage');
+    rejectUnknownKeys(obj, ['version', 'roots', 'backends', 'fallback'], source, 'storage');
     const roots = validateRoots(obj['roots'], source);
     const backends = validateBackends(obj['backends'], source);
     let fallback;
@@ -164,19 +164,24 @@ function validateBackendConfig(raw, source) {
     // — the adapter is responsible for any further validation it needs.
     switch (type) {
         case 'fs':
+            rejectUnknownKeys(obj, ['type'], source, 'backend');
             return { type: 'fs' };
         case 'obsidian':
+            rejectUnknownKeys(obj, ['type', 'vault', 'folder', 'useCli'], source, 'backend');
             requireString(obj, 'vault', source);
             return obj;
         case 'logseq':
+            rejectUnknownKeys(obj, ['type', 'graph', 'apiUrl', 'useApi'], source, 'backend');
             requireString(obj, 'graph', source);
             return obj;
         case 'notion': {
+            rejectUnknownKeys(obj, ['type', 'parent', 'externalIdProperty'], source, 'backend');
             const parent = obj['parent'];
             if (typeof parent !== 'object' || parent === null) {
                 throw new Error(`${source}.parent must be an object with pageId or databaseId`);
             }
             const p = parent;
+            rejectUnknownKeys(p, ['pageId', 'databaseId'], source, 'parent');
             const hasPage = typeof p['pageId'] === 'string' && p['pageId'].length > 0;
             const hasDb = typeof p['databaseId'] === 'string' && p['databaseId'].length > 0;
             if (hasPage === hasDb) {
@@ -185,21 +190,30 @@ function validateBackendConfig(raw, source) {
             return obj;
         }
         case 'anythingllm':
+            rejectUnknownKeys(obj, ['type', 'baseUrl', 'workspace', 'folder'], source, 'backend');
             requireString(obj, 'baseUrl', source);
             requireString(obj, 'workspace', source);
             return obj;
         case 'fortemi':
+            rejectUnknownKeys(obj, ['type', 'mcpServer', 'scheme'], source, 'backend');
             return obj;
         case 's3':
+            rejectUnknownKeys(obj, ['type', 'bucket', 'prefix', 'region', 'endpoint'], source, 'backend');
             requireString(obj, 'bucket', source);
             return obj;
         case 'webdav':
+            rejectUnknownKeys(obj, ['type', 'url', 'basePath', 'authMode'], source, 'backend');
             requireString(obj, 'url', source);
             return obj;
         default:
             throw new Error(`${source}: unhandled backend type ${type}`);
     }
 }
+function rejectUnknownKeys(obj, allowed, source, label) {
+    const unknown = Object.keys(obj).find(key => !allowed.includes(key));
+    if (unknown)
+        throw new Error(`${source}: ${label}.${unknown} is not a supported property`);
+}
 function requireString(obj, key, source) {
     const v = obj[key];
     if (typeof v !== 'string' || v.length === 0) {

package/dist/src/storage/fortemi-qualification.js

@@ -0,0 +1,106 @@
+import { randomUUID } from "node:crypto";
+import { FortemiAdapter } from "./backends/fortemi.js";
+export const FORTEMI_QUALIFICATION_VERSION = "aiwg.fortemi-live-qualification/v1";
+const EXPECTED = {
+    read: { tool: "get_note", required: ["note_id"], properties: ["note_id"] },
+    write: {
+        tool: "capture_knowledge",
+        required: ["note_id", "content"],
+        properties: ["note_id", "content"],
+    },
+    update: {
+        tool: "update_note",
+        required: ["note_id"],
+        properties: ["note_id", "content", "archived"],
+    },
+    list: { tool: "list_notes", required: [], properties: ["id_prefix"] },
+    query: {
+        tool: "search",
+        required: ["query"],
+        properties: ["query", "id_prefix"],
+    },
+};
+function bounded(work, timeoutMs, label) {
+    let timer;
+    return Promise.race([
+        work,
+        new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`FORTEMI_LIVE_TIMEOUT: ${label} exceeded ${timeoutMs}ms`)), timeoutMs);
+        }),
+    ]).finally(() => clearTimeout(timer));
+}
+/** Schema-first live qualification. No tool operation runs when preflight detects drift. */
+export async function qualifyLiveFortemi(client, options = {}) {
+    const timeoutMs = Math.max(250, Math.min(options.timeoutMs ?? 5_000, 30_000));
+    const namespace = `aiwg-qualification-${randomUUID()}`;
+    const report = {
+        schema: FORTEMI_QUALIFICATION_VERSION,
+        compatible: false,
+        mutationAttempted: false,
+        server: {
+            ...(client.serverVersion?.() ?? {}),
+            ...(options.contractRevision
+                ? { contractRevision: options.contractRevision }
+                : {}),
+        },
+        namespace,
+        operations: [],
+    };
+    try {
+        if (!client.listTools)
+            throw new Error("FORTEMI_TOOL_DISCOVERY_UNAVAILABLE");
+        const discovered = await bounded(client.listTools(), timeoutMs, "tools/list");
+        const tools = new Map((discovered.tools ?? []).map((tool) => [tool.name, tool]));
+        for (const [operation, expected] of Object.entries(EXPECTED)) {
+            const tool = tools.get(expected.tool);
+            const schema = tool?.inputSchema;
+            const properties = schema?.properties && typeof schema.properties === "object"
+                ? schema.properties
+                : {};
+            const required = Array.isArray(schema?.required)
+                ? schema.required.filter((value) => typeof value === "string")
+                : [];
+            const missing = expected.properties.filter((name) => !(name in properties));
+            const missingRequired = expected.required.filter((name) => !required.includes(name));
+            const compatible = Boolean(tool && schema) &&
+                missing.length === 0 &&
+                missingRequired.length === 0;
+            report.operations.push({
+                operation,
+                tool: expected.tool,
+                compatible,
+                code: compatible
+                    ? "FORTEMI_TOOL_SCHEMA_COMPATIBLE"
+                    : tool
+                        ? "FORTEMI_TOOL_SCHEMA_DRIFT"
+                        : "FORTEMI_TOOL_MISSING",
+                detail: compatible
+                    ? "expected adapter arguments are accepted"
+                    : `missing properties: ${missing.join(", ") || "none"}; not required: ${missingRequired.join(", ") || "none"}`,
+            });
+        }
+        report.compatible = report.operations.every((item) => item.compatible);
+        if (!report.compatible)
+            return report;
+        const adapter = new FortemiAdapter({
+            subsystem: namespace,
+            config: { type: "fortemi", mcpServer: "live-qualification" },
+            clientFactory: async () => client,
+        });
+        await bounded(adapter.init(), timeoutMs, "adapter init");
+        await bounded(adapter.read(randomUUID()), timeoutMs, "adapter read");
+        await bounded(adapter.list(""), timeoutMs, "adapter list");
+        await bounded(adapter.query(`aiwg qualification ${namespace}`), timeoutMs, "adapter query");
+        if (options.allowMutation) {
+            report.mutationAttempted = true;
+            await bounded(adapter.write(randomUUID(), `AIWG live qualification ${namespace}`, {
+                contentType: "text/plain",
+            }), timeoutMs, "adapter write");
+        }
+        return report;
+    }
+    finally {
+        await client.close?.();
+    }
+}
+//# sourceMappingURL=fortemi-qualification.js.map

package/dist/src/storage/index.js

@@ -21,6 +21,7 @@ export { FilesystemAdapter } from './backends/fs.js';
 export { ObsidianAdapter } from './backends/obsidian.js';
 export { LogseqAdapter } from './backends/logseq.js';
 export { FortemiAdapter } from './backends/fortemi.js';
+export { qualifyLiveFortemi, FORTEMI_QUALIFICATION_VERSION, } from './fortemi-qualification.js';
 export { STORAGE_BACKEND_CONTRACT, STORAGE_BACKEND_MATRIX, StorageCapabilityError, negotiateStorageCapabilities, } from './backend-contract.js';
 export { STORAGE_MIGRATION_PROTOCOL, MigrationProtocolError, StorageMigrationCoordinator, approvalDigest, digestRecordChunks, digestRecords, validateManifest, } from './migration-protocol.js';
 export { PostgresStorageBackend, PostgresBackendError, } from './backends/postgres.js';

package/dist/src/storage/types.js

@@ -6,7 +6,7 @@
  * conforming to `StorageAdapter`.
  *
  * @design @.aiwg/architecture/storage-design.md
- * @schema @.aiwg/architecture/schemas/storage.config.v1.json
+ * @schema @schemas/storage/storage.config.v1.schema.json
  * @issue #934
  * @issue #953
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwg/cli",
-  "version": "2026.9.0",
+  "version": "2026.9.2",
   "description": "Lightweight AIWG CLI for signed, versioned web-backed resources.",
   "type": "module",
   "license": "MIT",
@@ -28,12 +28,14 @@
     "bin/",
     "agentic/code/providers/",
     "schemas/security/",
+    "schemas/dataset/",
     "dist/src/",
     "!dist/**/*.d.ts",
     "!dist/**/*.map",
     "dist/src/api/index.d.ts",
     "dist/src/resources/index.d.ts",
     "dist/src/resources/web-release.d.ts",
+    "dist/src/dataset/**/*.d.ts",
     "tools/_resolve-impl.mjs",
     "tools/agents/deploy-agents.mjs",
     "tools/agents/providers/",

package/schemas/dataset/conformance-manifest.v1.schema.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://aiwg.io/schemas/dataset/conformance-manifest.v1.schema.json",
+  "title": "AIWG Dataset Intelligence Conformance Manifest v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["contract", "schemaVersion", "corpusVersion", "cells"],
+  "properties": {
+    "contract": { "const": "aiwg.dataset.conformance/v1" },
+    "schemaVersion": { "$ref": "#/$defs/version" },
+    "corpusVersion": { "$ref": "#/$defs/version" },
+    "cells": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/cell" } }
+  },
+  "$defs": {
+    "version": { "type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+(?:[-+][0-9A-Za-z.-]+)?$" },
+    "digest": { "type": "string", "pattern": "^sha256:[0-9a-f]{64}$" },
+    "cell": {
+      "type": "object", "additionalProperties": false,
+      "required": ["id", "area", "requiredCapabilities", "sourceClass", "runtimeClass", "fixture", "expected", "maturity", "evidence", "resourceEnvelope"],
+      "properties": {
+        "id": { "type": "string", "pattern": "^[a-z0-9][a-z0-9.-]+$" },
+        "area": { "enum": ["adapter", "capability", "replay", "checkpoint", "provenance", "security", "offline", "parity", "standards", "migration"] },
+        "requiredCapabilities": { "type": "array", "items": { "type": "string", "minLength": 1 }, "uniqueItems": true },
+        "sourceClass": { "enum": ["synthetic", "file", "directory", "jsonl", "csv", "http", "cache", "fortemi"] },
+        "runtimeClass": { "enum": ["local", "fortemi-core", "fortemi-server"] },
+        "fixture": { "type": "object", "additionalProperties": false, "required": ["path", "digest", "revision"], "properties": { "path": { "type": "string", "pattern": "^test/fixtures/dataset-intelligence/" }, "digest": { "$ref": "#/$defs/digest" }, "revision": { "$ref": "#/$defs/version" } } },
+        "expected": { "type": "object", "additionalProperties": false, "required": ["result"], "properties": { "result": { "enum": ["pass", "reject", "pending"] }, "diagnostic": { "type": "string", "minLength": 1 } } },
+        "maturity": { "enum": ["experimental", "qualified", "stable"] },
+        "evidence": { "type": "array", "minItems": 1, "items": { "enum": ["fixture", "real-source", "cross-repo", "live-qualification"] }, "uniqueItems": true },
+        "resourceEnvelope": { "type": "object", "additionalProperties": false, "required": ["maxBytes", "maxRecords", "maxDurationMs"], "properties": { "maxBytes": { "type": "integer", "minimum": 1 }, "maxRecords": { "type": "integer", "minimum": 1 }, "maxDurationMs": { "type": "integer", "minimum": 1 } } },
+        "liveAuthorizationRequired": { "type": "boolean" }
+      }
+    }
+  }
+}

package/schemas/dataset/conformance-receipt.v1.schema.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://aiwg.io/schemas/dataset/conformance-receipt.v1.schema.json",
+  "title": "AIWG Dataset Intelligence Conformance Receipt v1",
+  "type": "object", "additionalProperties": false,
+  "required": ["contract", "schemaVersion", "corpusVersion", "manifestDigest", "resultDigest", "bindings", "startedAt", "endedAt", "results", "summary"],
+  "properties": {
+    "contract": { "const": "aiwg.dataset.conformance/v1" }, "schemaVersion": { "$ref": "#/$defs/version" }, "corpusVersion": { "$ref": "#/$defs/version" },
+    "manifestDigest": { "$ref": "#/$defs/digest" }, "resultDigest": { "$ref": "#/$defs/digest" },
+    "startedAt": { "$ref": "#/$defs/time" }, "endedAt": { "$ref": "#/$defs/time" },
+    "bindings": { "$ref": "#/$defs/bindings" },
+    "results": { "type": "array", "items": { "$ref": "#/$defs/result" } },
+    "summary": { "type": "object", "additionalProperties": false, "required": ["passed", "failed", "pending", "stableEligible"], "properties": { "passed": { "type": "integer", "minimum": 0 }, "failed": { "type": "integer", "minimum": 0 }, "pending": { "type": "integer", "minimum": 0 }, "stableEligible": { "type": "boolean" } } }
+  },
+  "$defs": {
+    "version": { "type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+(?:[-+][0-9A-Za-z.-]+)?$" }, "digest": { "type": "string", "pattern": "^sha256:[0-9a-f]{64}$" }, "time": { "type": "string", "format": "date-time", "pattern": "Z$" },
+    "digestMap": { "type": "object", "minProperties": 1, "additionalProperties": { "$ref": "#/$defs/digest" } },
+    "bindings": { "type": "object", "additionalProperties": false, "required": ["aiwgCommit", "packageDigests", "schemaDigests", "fixtureDigest", "configurationDigest"], "properties": { "aiwgCommit": { "type": "string", "pattern": "^(?:[0-9a-f]{40}|sha256:[0-9a-f]{64})$" }, "fortemiCommit": { "type": "string", "pattern": "^[0-9a-f]{40}$" }, "packageDigests": { "$ref": "#/$defs/digestMap" }, "schemaDigests": { "$ref": "#/$defs/digestMap" }, "fixtureDigest": { "$ref": "#/$defs/digest" }, "descriptorDigest": { "$ref": "#/$defs/digest" }, "configurationDigest": { "$ref": "#/$defs/digest" } } },
+    "evidence": { "type": "object", "additionalProperties": false, "required": ["kind", "reference", "digest"], "properties": { "kind": { "enum": ["fixture", "real-source", "cross-repo", "live-qualification"] }, "reference": { "type": "string", "minLength": 1 }, "digest": { "$ref": "#/$defs/digest" } } },
+    "result": { "type": "object", "additionalProperties": false, "required": ["cellId", "status", "evidence", "observed"], "properties": { "cellId": { "type": "string", "minLength": 1 }, "status": { "enum": ["passed", "failed", "pending"] }, "diagnostic": { "type": "string", "minLength": 1 }, "evidence": { "type": "array", "items": { "$ref": "#/$defs/evidence" } }, "observed": { "type": "object", "additionalProperties": false, "required": ["networkAttempts"], "properties": { "records": { "type": "integer", "minimum": 0 }, "bytes": { "type": "integer", "minimum": 0 }, "durationMs": { "type": "integer", "minimum": 0 }, "networkAttempts": { "type": "integer", "minimum": 0 } } } } }
+  }
+}