@aiwg/cli 2026.9.20 → 2026.9.21

package/dist/src/smiths/hook-bridge/shim.js

@@ -52,6 +52,8 @@ export const EXIT_CODE_MAP = {
     factory: { allow: 0, block: 1, warn: 0 },
     hermes: { allow: 0, block: 1, warn: 2 },
     openclaw: { allow: 0, block: 1, warn: 2 },
+    // Grok only honors an explicit PreToolUse deny decision; other failures are fail-open.
+    'grok-build': { allow: 0, block: 2, warn: 0 },
 };
 /**
  * Generate a small bash shim that:

package/dist/src/smiths/hook-bridge/types.js

@@ -27,5 +27,10 @@ export const NATIVE_ENV_VAR_MAP = {
     copilot: {
         PROJECT_DIR: '$GITHUB_WORKSPACE',
     },
+    'grok-build': {
+        PROJECT_DIR: '$GROK_WORKSPACE_ROOT',
+        HOOK_EVENT: '$GROK_HOOK_EVENT',
+        SESSION_ID: '$GROK_SESSION_ID',
+    },
 };
 //# sourceMappingURL=types.js.map

package/dist/src/smiths/skillsmith/collision-detector.js

@@ -37,6 +37,7 @@ const PLATFORM_BUILTINS = {
     'warp': ['help', 'settings'],
     'hermes': [],
     'grokbot': [],
+    'muse': [],
     'openclaw': [],
     'openhuman': [],
     'factory': [],

package/dist/src/storage/protected-files.js

@@ -0,0 +1,102 @@
+/**
+ * Protected local file primitives shared by durable stores.
+ *
+ * Records are stored as exact RFC 8785 canonical bytes, keyed with HMAC-SHA256,
+ * kept in owner-only directories, and published with exclusive hard links so a
+ * destination is written at most once. Nothing here knows about any caller's
+ * lifecycle or error taxonomy: callers supply their own error factories.
+ *
+ * This module must not import from `src/decision/**`.
+ */
+import { createHmac, randomUUID, timingSafeEqual } from 'node:crypto';
+import { link, lstat, mkdir, open, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { canonicalJson } from '../security/artifact-trust.js';
+/** Opaque by default: callers learn only that stored bytes failed verification. */
+export class ProtectedFileIntegrityError extends Error {
+    constructor() { super('Protected file integrity check failed'); this.name = 'ProtectedFileIntegrityError'; }
+}
+export function requireIntegrityKey(key, label) {
+    if (!(key instanceof Uint8Array) || key.length < 32)
+        throw new Error(`${label} integrity key must be at least 32 bytes`);
+    return Buffer.from(key);
+}
+export function keyedName(key, domain, parts) {
+    return createHmac('sha256', key).update(`${domain}\0`).update(parts.join('\0')).digest('hex');
+}
+export function macFor(key, domain, value) {
+    return createHmac('sha256', key).update(`${domain}:`).update(canonicalJson(value)).digest('hex');
+}
+export function macMatches(key, domain, value, mac) {
+    return typeof mac === 'string' && /^[a-f0-9]{64}$/.test(mac)
+        && timingSafeEqual(Buffer.from(mac, 'hex'), Buffer.from(macFor(key, domain, value), 'hex'));
+}
+/** Stored bytes must be exactly the canonical serialization, so no byte can change unnoticed. */
+export function serialized(value) { return `${canonicalJson(value)}\n`; }
+/** Parse stored bytes, refusing anything that is not exactly its canonical serialization. */
+export function parseCanonical(raw, integrityError = () => new ProtectedFileIntegrityError()) {
+    const parsed = JSON.parse(raw);
+    if (serialized(parsed) !== raw)
+        throw integrityError();
+    return parsed;
+}
+/** Create (if needed) and require an owner-only directory. Any group or other permission bit is refused. */
+export async function ensurePrivateDirectory(directory, message, error = (text) => new Error(text)) {
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const stat = await lstat(directory);
+    if (!stat.isDirectory() || (stat.mode & 0o077) !== 0)
+        throw error(message);
+}
+export async function syncDirectory(directory) {
+    const handle = await open(directory, 'r');
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function exists(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+/** Exclusive hard-link publication. Returns false when the destination already exists. */
+export async function publishExclusive(directory, destination, contents, temporaryPrefix) {
+    const temporary = join(directory, `.${temporaryPrefix}-${randomUUID()}.tmp`);
+    const handle = await open(temporary, 'wx', 0o600);
+    try {
+        await handle.writeFile(contents, 'utf8');
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    try {
+        await link(temporary, destination);
+    }
+    catch (error) {
+        if (error.code === 'EEXIST')
+            return false;
+        throw error;
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    await syncDirectory(directory);
+    return true;
+}
+/**
+ * Publish a body-free tombstone record in canonical form. An existing tombstone
+ * already has the same effect, so publication is idempotent.
+ */
+export async function publishTombstone(directory, path, record, temporaryPrefix) {
+    await publishExclusive(directory, path, serialized(record), temporaryPrefix);
+}
+//# sourceMappingURL=protected-files.js.map

package/dist/src/tracker/forge-http.js

@@ -0,0 +1,371 @@
+/**
+ * Read-only, bounded, paginated Gitea/GitHub REST reads for tracker effect
+ * verifiers (#2719).
+ *
+ * This is the TypeScript port of the forge layer in
+ * `tools/security/pr-evidence-forge.mjs` (bounded bodies, header-driven
+ * pagination, provider-specific auth headers), plus the reads the verifiers
+ * need: issue state, one page of issue comments, PR merge state and a commit
+ * message. Two transports share one parser: HTTP (`fetch`) and the forge CLI
+ * (`gh api --include`).
+ *
+ * Every failure is a `ForgeReadError` with a fixed message and a classified
+ * `code`. Access material stays inside the transport: it is never part of an
+ * error, a result or a log line.
+ */
+import { spawn } from 'node:child_process';
+export class ForgeReadError extends Error {
+    code;
+    status;
+    constructor(code, status) {
+        super(`Forge read failed: ${code}${status ? ` (HTTP ${status})` : ''}`);
+        this.code = code;
+        this.status = status;
+        this.name = 'ForgeReadError';
+    }
+}
+export const FORGE_MAX_RESPONSE_BYTES = 2_000_000;
+const REPOSITORY = /^[\w.-]+\/[\w.-]+$/;
+const OBJECT_ID = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
+async function boundedBody(response, maxBytes) {
+    const declared = Number(response.headers.get('content-length'));
+    if (Number.isFinite(declared) && declared > maxBytes) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new ForgeReadError('oversized');
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        if (bytes.length > maxBytes)
+            throw new ForgeReadError('oversized');
+        return bytes;
+    }
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            size += value.length;
+            if (size > maxBytes) {
+                await reader.cancel().catch(() => undefined);
+                throw new ForgeReadError('oversized');
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const result = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return result;
+}
+const aborted = (signal) => signal?.aborted === true;
+/** HTTP transport over `fetch`, with the provider's auth header and a response bound. */
+export function httpForgeTransport(options) {
+    if (!/^https?:\/\//.test(options.apiBaseUrl ?? ''))
+        throw new TypeError('A trusted API base URL is required');
+    const base = options.apiBaseUrl.replace(/\/+$/, '');
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const maxBytes = options.maxResponseBytes ?? FORGE_MAX_RESPONSE_BYTES;
+    const authorization = options.provider === 'github' ? `Bearer ${options.token}` : `token ${options.token}`;
+    return async (path, signal) => {
+        let response;
+        try {
+            response = await fetchImpl(`${base}${path}`, {
+                method: 'GET',
+                headers: { accept: 'application/json', authorization },
+                redirect: 'error',
+                ...(signal ? { signal } : {}),
+            });
+        }
+        catch {
+            throw new ForgeReadError(aborted(signal) ? 'timeout' : 'network-error');
+        }
+        const headers = {};
+        response.headers.forEach((value, name) => { headers[name.toLowerCase()] = value; });
+        let body;
+        try {
+            body = await boundedBody(response, maxBytes);
+        }
+        catch (error) {
+            if (error instanceof ForgeReadError)
+                throw error;
+            throw new ForgeReadError(aborted(signal) ? 'timeout' : 'network-error');
+        }
+        return { status: response.status, headers, body };
+    };
+}
+function spawnCliRunner(binary, maxBytes) {
+    return (args, signal) => new Promise((resolve, reject) => {
+        const child = spawn(binary, args, {
+            stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true, ...(signal ? { signal } : {}),
+            env: { ...process.env, GH_PROMPT_DISABLED: '1', NO_COLOR: '1', GH_NO_UPDATE_NOTIFIER: '1' },
+        });
+        const chunks = [];
+        let size = 0;
+        let oversized = false;
+        child.stdout.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > maxBytes + 65_536) {
+                oversized = true;
+                child.kill();
+            }
+            else
+                chunks.push(chunk);
+        });
+        child.once('error', () => reject(new ForgeReadError(aborted(signal) ? 'timeout' : 'network-error')));
+        child.once('close', code => {
+            if (oversized)
+                reject(new ForgeReadError('oversized'));
+            else
+                resolve({ stdout: new Uint8Array(Buffer.concat(chunks)), exitCode: code ?? 1 });
+        });
+    });
+}
+/** Split `gh api --include` output into status, headers and body. */
+export function parseIncludedResponse(output) {
+    const text = Buffer.from(output);
+    let split = text.indexOf('\r\n\r\n');
+    let gap = 4;
+    if (split < 0) {
+        split = text.indexOf('\n\n');
+        gap = 2;
+    }
+    if (split < 0)
+        throw new ForgeReadError('malformed');
+    const head = text.subarray(0, split).toString('latin1').split(/\r?\n/);
+    const status = /^HTTP\/[0-9.]+ ([0-9]{3})\b/.exec(head[0] ?? '');
+    if (!status)
+        throw new ForgeReadError('malformed');
+    const headers = {};
+    for (const line of head.slice(1)) {
+        const colon = line.indexOf(':');
+        if (colon > 0)
+            headers[line.slice(0, colon).trim().toLowerCase()] = line.slice(colon + 1).trim();
+    }
+    return { status: Number(status[1]), headers, body: new Uint8Array(text.subarray(split + gap)) };
+}
+/**
+ * CLI transport: `gh api --include --hostname <host> <path>`. The CLI holds
+ * its own credentials. Gitea has no CLI with a raw read API (`tea` has no
+ * `api` command), so only GitHub is supported.
+ */
+export function cliForgeTransport(options) {
+    if (options.provider !== 'github')
+        throw new TypeError('The forge CLI transport supports GitHub only');
+    if (!/^[A-Za-z0-9.-]+(?::[0-9]+)?$/.test(options.hostname ?? ''))
+        throw new TypeError('A forge hostname is required');
+    const maxBytes = options.maxResponseBytes ?? FORGE_MAX_RESPONSE_BYTES;
+    const runner = options.runner ?? spawnCliRunner(options.binary ?? 'gh', maxBytes);
+    return async (path, signal) => {
+        if (!path.startsWith('/'))
+            throw new ForgeReadError('malformed');
+        const { stdout, exitCode } = await runner(['api', '--include', '--method', 'GET', '--hostname', options.hostname, path.slice(1)], signal)
+            .catch((error) => {
+            if (error instanceof ForgeReadError)
+                throw error;
+            throw new ForgeReadError(aborted(signal) ? 'timeout' : 'network-error');
+        });
+        // `gh api --include` prints the status line even for a non-2xx exit. With
+        // nothing on stdout the CLI never reached the API: exit 4 is gh's
+        // "authentication required".
+        if (stdout.length === 0 && exitCode !== 0)
+            throw new ForgeReadError(exitCode === 4 ? 'auth-denied' : 'network-error');
+        const parsed = parseIncludedResponse(stdout);
+        if (parsed.body.length > maxBytes)
+            throw new ForgeReadError('oversized');
+        return parsed;
+    };
+}
+/** Classify a non-2xx response. A GitHub 403 with an exhausted quota is a rate limit, not an auth failure. */
+export function classifyStatus(response) {
+    const { status, headers } = response;
+    if (status >= 200 && status < 300)
+        return null;
+    if (status === 429)
+        return 'rate-limited';
+    if (status === 403 && (headers['x-ratelimit-remaining'] === '0' || headers['retry-after'] !== undefined))
+        return 'rate-limited';
+    if (status === 401 || status === 403)
+        return 'auth-denied';
+    if (status === 404 || status === 410)
+        return 'not-found';
+    if (status >= 500)
+        return 'server-error';
+    return 'unexpected-status';
+}
+function parseJson(response) {
+    const failure = classifyStatus(response);
+    if (failure)
+        throw new ForgeReadError(failure, response.status);
+    try {
+        return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(response.body));
+    }
+    catch {
+        throw new ForgeReadError('malformed');
+    }
+}
+/**
+ * Pagination from the provider headers (`x-hasmore`, `link rel="next"`,
+ * `x-total-count` / `x-total`). A full page with no pagination signal is
+ * ambiguous and never complete.
+ */
+export function forgePagination(headers, items, page, pageSize) {
+    const totalHeader = headers['x-total-count'] ?? headers['x-total'];
+    const total = totalHeader !== undefined && /^[0-9]+$/.test(totalHeader) ? Number(totalHeader) : undefined;
+    const hasMore = headers['x-hasmore'];
+    if (items.length > pageSize) {
+        // The server ignored the page size and returned the whole collection at once.
+        const whole = page === 1 && hasMore !== 'true' && (total === undefined || total === items.length);
+        return { items, nextPage: null, complete: whole, ...(total !== undefined ? { totalCount: total } : {}) };
+    }
+    const linkedNext = /<[^>]+[?&]page=(\d+)[^>]*>;\s*rel="next"/.exec(headers.link ?? '');
+    const nextPage = hasMore === 'true' ? page + 1
+        : hasMore === 'false' ? null
+            : linkedNext ? Number(linkedNext[1])
+                : total !== undefined && items.length === pageSize && page * pageSize < total ? page + 1 : null;
+    const ambiguous = hasMore === undefined && !linkedNext && total === undefined && items.length === pageSize;
+    const totalsAgree = total === undefined || total === (page - 1) * pageSize + items.length;
+    return { items, nextPage, complete: !ambiguous && nextPage === null && totalsAgree, ...(total !== undefined ? { totalCount: total } : {}) };
+}
+const str = (value) => (typeof value === 'string' ? value : null);
+const login = (user) => {
+    if (!user || typeof user !== 'object')
+        return null;
+    const value = user;
+    return str(value.login) ?? str(value.username);
+};
+function repoPath(repository, number) {
+    if (!REPOSITORY.test(repository) || repository.split('/').some(part => part === '.' || part === '..'))
+        throw new ForgeReadError('malformed');
+    if (number !== undefined && (!Number.isSafeInteger(number) || number < 1))
+        throw new ForgeReadError('malformed');
+    return `/repos/${repository.split('/').map(encodeURIComponent).join('/')}`;
+}
+/** Build the read-only reader over one transport. */
+export function createForgeReader(provider, transport, options = {}) {
+    const pageSize = options.pageSize ?? (provider === 'github' ? 100 : 50);
+    const get = async (path, signal) => {
+        if (aborted(signal))
+            throw new ForgeReadError('timeout');
+        return transport(path, signal);
+    };
+    const object = (value) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new ForgeReadError('malformed');
+        return value;
+    };
+    return {
+        provider,
+        pageSize,
+        async getIssue(repository, number, signal) {
+            const issue = object(parseJson(await get(`${repoPath(repository, number)}/issues/${number}`, signal)));
+            const state = issue.state;
+            if (state !== 'open' && state !== 'closed')
+                throw new ForgeReadError('malformed');
+            const found = issue.number ?? issue.index;
+            if (found !== undefined && found !== number)
+                throw new ForgeReadError('malformed');
+            return { number, state, closedAt: str(issue.closed_at), isPullRequest: Boolean(issue.pull_request) };
+        },
+        async listIssueComments(repository, number, page, signal) {
+            if (!Number.isSafeInteger(page) || page < 1)
+                throw new ForgeReadError('malformed');
+            const sizeParam = provider === 'github' ? 'per_page' : 'limit';
+            const response = await get(`${repoPath(repository, number)}/issues/${number}/comments?page=${page}&${sizeParam}=${pageSize}`, signal);
+            const raw = parseJson(response);
+            if (!Array.isArray(raw))
+                throw new ForgeReadError('malformed');
+            const items = raw.map((entry) => {
+                const item = object(entry);
+                if (typeof item.id !== 'number')
+                    throw new ForgeReadError('malformed');
+                return { id: item.id, author: login(item.user) ?? login(item.poster), body: str(item.body) ?? '', createdAt: str(item.created_at) };
+            });
+            return forgePagination(response.headers, items, page, pageSize);
+        },
+        async getPullState(repository, number, signal) {
+            const pr = object(parseJson(await get(`${repoPath(repository, number)}/pulls/${number}`, signal)));
+            const state = pr.state;
+            if (state !== 'open' && state !== 'closed')
+                throw new ForgeReadError('malformed');
+            if (typeof pr.merged !== 'boolean')
+                throw new ForgeReadError('malformed');
+            const base = pr.base && typeof pr.base === 'object' ? pr.base : {};
+            const head = pr.head && typeof pr.head === 'object' ? pr.head : {};
+            const mergeSha = str(pr.merge_commit_sha);
+            return {
+                number,
+                state,
+                merged: pr.merged,
+                mergedAt: str(pr.merged_at),
+                mergeCommitSha: pr.merged && mergeSha && OBJECT_ID.test(mergeSha) ? mergeSha : null,
+                baseRef: str(base.ref),
+                baseSha: str(base.sha),
+                headSha: str(head.sha),
+            };
+        },
+        async getCommitMessage(repository, sha, signal) {
+            if (!OBJECT_ID.test(sha))
+                throw new ForgeReadError('malformed');
+            const path = provider === 'github' ? `${repoPath(repository)}/commits/${sha}` : `${repoPath(repository)}/git/commits/${sha}`;
+            const commit = object(parseJson(await get(path, signal)));
+            const inner = commit.commit && typeof commit.commit === 'object' ? commit.commit : commit;
+            return str(inner.message);
+        },
+    };
+}
+/**
+ * Derive the REST API base from a tracker remote URL (`git@host:o/r.git`,
+ * `ssh://git@host:2222/o/r.git`, `https://host/prefix/o/r.git`). Returns the
+ * host, the `owner/repo` path and the API base, or null when the URL cannot
+ * be parsed. No host is assumed: the base always comes from the remote.
+ */
+export function forgeEndpointFromRemote(provider, remoteUrl) {
+    if (!remoteUrl)
+        return null;
+    let origin;
+    let host;
+    let path;
+    const scp = /^[\w.-]+@([A-Za-z0-9.-]+):(?!\/)(.+)$/.exec(remoteUrl);
+    if (scp) {
+        host = scp[1];
+        origin = `https://${host}`;
+        path = scp[2];
+    }
+    else {
+        let url;
+        try {
+            url = new URL(remoteUrl);
+        }
+        catch {
+            return null;
+        }
+        if (!['https:', 'http:', 'ssh:', 'git:'].includes(url.protocol) || !url.hostname)
+            return null;
+        host = url.hostname;
+        const web = url.protocol === 'https:' || url.protocol === 'http:';
+        origin = web ? `${url.protocol}//${url.host}` : `https://${host}`;
+        path = url.pathname.replace(/^\/+/, '');
+    }
+    const parts = path.replace(/\.git$/, '').replace(/\/+$/, '').split('/').filter(Boolean);
+    if (parts.length < 2)
+        return null;
+    const repository = parts.slice(-2).join('/');
+    if (!REPOSITORY.test(repository))
+        return null;
+    const prefix = parts.slice(0, -2).join('/');
+    const webBase = prefix ? `${origin}/${prefix}` : origin;
+    const apiBaseUrl = provider === 'github'
+        ? (host.toLowerCase() === 'github.com' ? 'https://api.github.com' : `${webBase}/api/v3`)
+        : `${webBase}/api/v1`;
+    return { host: host.toLowerCase(), repository, apiBaseUrl };
+}
+//# sourceMappingURL=forge-http.js.map

package/dist/src/tracker/project-inputs.js

@@ -0,0 +1,41 @@
+/**
+ * Project inputs for tracker authority: the `.aiwg/aiwg.config` and the git
+ * remote URLs. Shared by context finalization and the `aiwg effect` tracker
+ * verifiers, so both resolve the tracker from the same facts.
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { readAiwgConfig } from '../config/aiwg-config.js';
+const execFileAsync = promisify(execFile);
+/** The project config, or `null` when it is missing or unreadable. */
+export async function readConfig(projectPath) {
+    try {
+        return await readAiwgConfig(projectPath);
+    }
+    catch {
+        return null;
+    }
+}
+/** Git remote name to fetch URL; `{}` outside a repository or when git fails. */
+export async function readGitRemoteUrls(projectPath) {
+    try {
+        const { stdout } = await execFileAsync('git', ['-C', projectPath, 'remote', '-v'], {
+            maxBuffer: 1024 * 1024,
+            timeout: 10_000,
+        });
+        const urls = {};
+        for (const line of stdout.split(/\r?\n/)) {
+            const match = line.match(/^(\S+)\s+(\S+)\s+\((fetch|push)\)$/);
+            if (!match)
+                continue;
+            const [, name, url, direction] = match;
+            if (direction === 'fetch' || !urls[name])
+                urls[name] = url;
+        }
+        return urls;
+    }
+    catch {
+        return {};
+    }
+}
+//# sourceMappingURL=project-inputs.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwg/cli",
-  "version": "2026.9.20",
+  "version": "2026.9.21",
   "description": "Lightweight AIWG CLI for signed, versioned web-backed resources.",
   "type": "module",
   "license": "MIT",
@@ -28,6 +28,7 @@
     "bin/",
     "agentic/code/providers/",
     "schemas/security/",
+    "schemas/decision/",
     "schemas/dataset/",
     "dist/src/",
     "!dist/**/*.d.ts",

package/schemas/decision/BatchReceipt.v1.schema.json

@@ -0,0 +1,50 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://aiwg.io/schemas/decision/BatchReceipt.v1.schema.json",
+  "title": "Decision Batch Receipt v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "revision", "tenantId", "projectId", "batchId", "invocationId", "runId", "plan", "subjectHash", "stateHash", "executionEnvelope", "questionIds", "attempts", "answerReferences", "allocations", "status", "createdAtEpochMs", "updatedAtEpochMs", "terminalAtEpochMs"],
+  "properties": {
+    "schemaVersion": { "const": "decision-batch-receipt/v1" },
+    "revision": { "type": "integer", "minimum": 1 },
+    "tenantId": { "$ref": "#/$defs/text" }, "projectId": { "$ref": "#/$defs/text" },
+    "batchId": { "$ref": "#/$defs/text" }, "invocationId": { "$ref": "#/$defs/text" }, "runId": { "$ref": "#/$defs/text" },
+    "plan": { "type": "object", "additionalProperties": false, "required": ["planDigest", "partitionId", "nativeBatchGroupId"], "properties": {
+      "planDigest": { "$ref": "#/$defs/hash" }, "partitionId": { "$ref": "#/$defs/text" },
+      "nativeBatchGroupId": { "type": ["string", "null"], "minLength": 1 }
+    } },
+    "subjectHash": { "$ref": "#/$defs/hash" }, "stateHash": { "$ref": "#/$defs/hash" },
+    "executionEnvelope": { "$ref": "#/$defs/text" },
+    "questionIds": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/text" } },
+    "attempts": { "type": "array", "items": { "$ref": "#/$defs/attempt" } },
+    "answerReferences": { "type": "array", "items": { "$ref": "#/$defs/answer" } },
+    "allocations": { "type": "array", "items": { "$ref": "#/$defs/allocation" } },
+    "status": { "enum": ["acquired", "running", "completed", "failed", "execution-uncertain"] },
+    "createdAtEpochMs": { "$ref": "#/$defs/time" }, "updatedAtEpochMs": { "$ref": "#/$defs/time" },
+    "terminalAtEpochMs": { "oneOf": [{ "$ref": "#/$defs/time" }, { "type": "null" }] },
+    "traceParent": { "type": "string", "pattern": "^00-[0-9a-f]{32}-[0-9a-f]{16}-0[01]$" }
+  },
+  "$defs": {
+    "text": { "type": "string", "minLength": 1 }, "time": { "type": "integer", "minimum": 0 },
+    "count": { "type": "integer", "minimum": 0 }, "nullableCount": { "oneOf": [{ "$ref": "#/$defs/count" }, { "type": "null" }] },
+    "hash": { "type": "string", "pattern": "^sha256:[0-9a-f]{64}$" },
+    "usage": { "type": "object", "additionalProperties": false, "required": ["inputTokens", "outputTokens"], "properties": { "inputTokens": { "$ref": "#/$defs/nullableCount" }, "outputTokens": { "$ref": "#/$defs/nullableCount" } } },
+    "cost": { "oneOf": [
+      { "type": "object", "additionalProperties": false, "required": ["kind", "currency", "amountMicros"], "properties": { "kind": { "const": "provider-authoritative" }, "currency": { "const": "USD" }, "amountMicros": { "$ref": "#/$defs/count" } } },
+      { "type": "object", "additionalProperties": false, "required": ["kind", "currency", "amountMicros", "priceCatalogId", "priceCatalogVersion", "effectiveAt"], "properties": { "kind": { "const": "client-derived" }, "currency": { "const": "USD" }, "amountMicros": { "$ref": "#/$defs/count" }, "priceCatalogId": { "$ref": "#/$defs/text" }, "priceCatalogVersion": { "$ref": "#/$defs/text" }, "effectiveAt": { "$ref": "#/$defs/text" } } },
+      { "type": "object", "additionalProperties": false, "required": ["kind", "currency", "upperBoundMicros", "boundPolicyId", "boundPolicyVersion"], "properties": { "kind": { "const": "bounded-unknown" }, "currency": { "const": "USD" }, "upperBoundMicros": { "$ref": "#/$defs/count" }, "boundPolicyId": { "$ref": "#/$defs/text" }, "boundPolicyVersion": { "$ref": "#/$defs/text" } } },
+      { "type": "object", "additionalProperties": false, "required": ["kind"], "properties": { "kind": { "const": "unknown" } } }
+    ] },
+    "attempt": { "type": "object", "additionalProperties": false, "required": ["ordinal", "adapterId", "adapterVersion", "requestedModel", "actualModel", "providerRequestId", "status", "dispatchedAtEpochMs", "completedAtEpochMs", "usage", "cost", "fallbackFromAttemptOrdinal"], "properties": {
+      "ordinal": { "type": "integer", "minimum": 1 }, "adapterId": { "$ref": "#/$defs/text" }, "adapterVersion": { "$ref": "#/$defs/text" }, "requestedModel": { "$ref": "#/$defs/text" },
+      "actualModel": { "type": ["string", "null"] }, "providerRequestId": { "type": ["string", "null"], "minLength": 1, "maxLength": 256, "pattern": "^[!-~]+$" },
+      "status": { "enum": ["not-sent", "failed", "succeeded", "execution-uncertain"] },
+      "dispatchedAtEpochMs": { "oneOf": [{ "$ref": "#/$defs/time" }, { "type": "null" }] }, "completedAtEpochMs": { "oneOf": [{ "$ref": "#/$defs/time" }, { "type": "null" }] },
+      "usage": { "$ref": "#/$defs/usage" }, "cost": { "$ref": "#/$defs/cost" },
+      "fallbackFromAttemptOrdinal": { "type": ["integer", "null"], "minimum": 1 }
+    } },
+    "answer": { "type": "object", "additionalProperties": false, "required": ["questionId", "answerId", "resultId"], "properties": { "questionId": { "$ref": "#/$defs/text" }, "answerId": { "$ref": "#/$defs/text" }, "resultId": { "$ref": "#/$defs/text" } } },
+    "allocation": { "type": "object", "additionalProperties": false, "required": ["questionId", "kind", "algorithm", "algorithmVersion", "inputTokens", "outputTokens"], "properties": { "questionId": { "$ref": "#/$defs/text" }, "kind": { "const": "estimated" }, "algorithm": { "const": "largest-remainder-weighted" }, "algorithmVersion": { "const": "1" }, "inputTokens": { "$ref": "#/$defs/nullableCount" }, "outputTokens": { "$ref": "#/$defs/nullableCount" } } }
+  }
+}