@aiwg/cli 2026.10.8 → 2026.10.10

package/dist/src/config/worker-owner-lock.js

@@ -0,0 +1,152 @@
+// Publishes complete owner identities atomically and fences dead-owner takeover by generation.
+import { randomUUID } from 'node:crypto';
+import { hostname } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { mkdir, writeFile, symlink, readlink, unlink, rm, readdir } from 'node:fs/promises';
+import { readFileSync, readlinkSync } from 'node:fs';
+import { projectControlPath } from './project-artifacts.js';
+export const workerWriteLock = (project) => projectControlPath(project, 'aiwg.config.apply-lock');
+const missing = (error) => error.code === 'ENOENT';
+function processStart(pid) {
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
+        return `${readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim()}:${stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19]}`;
+    }
+    catch {
+        return null;
+    }
+}
+function identity() {
+    return { generation: randomUUID(), host: hostname(), pid: process.pid, start: processStart(process.pid) };
+}
+function provablyDead(owner) {
+    if (owner.released)
+        return true; // The operation ended and explicitly relinquished exclusion.
+    if (owner.host !== hostname() || !Number.isSafeInteger(owner.pid) || owner.pid <= 0)
+        return false;
+    try {
+        process.kill(owner.pid, 0);
+    }
+    catch (error) {
+        return error.code === 'ESRCH';
+    }
+    const start = processStart(owner.pid);
+    return typeof owner.start === 'string' && owner.start.length > 0 && start !== null && owner.start !== start;
+}
+function latest(directory) {
+    let owner = JSON.parse(readFileSync(join(directory, 'owner.json'), 'utf8'));
+    // Immutable successor links are a compare-and-swap: only one contender can claim a generation.
+    for (;;) {
+        if (!/^[a-f0-9-]{36}$/.test(owner.generation))
+            throw new Error('Invalid worker lock generation');
+        try {
+            owner = JSON.parse(readlinkSync(join(directory, `next-${owner.generation}`)));
+        }
+        catch (error) {
+            if (missing(error))
+                return owner;
+            throw error;
+        }
+    }
+}
+async function sweepOrphanedOwners(path) {
+    const parent = dirname(path);
+    const prefix = `${basename(path)}.`;
+    for (const entry of await readdir(parent, { withFileTypes: true })) {
+        if (!entry.isDirectory() || !entry.name.startsWith(prefix) || !/^[a-f0-9-]{36}$/.test(entry.name.slice(prefix.length)))
+            continue;
+        const directory = join(parent, entry.name);
+        let owner;
+        try {
+            owner = latest(directory);
+        }
+        catch {
+            continue;
+        } // Incomplete or unreadable identities cannot prove death.
+        if (!provablyDead(owner))
+            continue;
+        try {
+            if (resolve(parent, await readlink(path)) === directory)
+                continue;
+        }
+        catch (error) {
+            if (!missing(error))
+                throw error;
+        }
+        await rm(directory, { recursive: true, force: true });
+    }
+}
+function lease(path, directory, owner) {
+    const assertOwned = () => {
+        try {
+            if (readlinkSync(path) === basename(directory) && latest(directory).generation === owner.generation)
+                return;
+        }
+        catch { /* Missing or replaced ownership must never authorize another write. */ }
+        throw new Error(`Worker configuration lock ownership lost (${owner.generation}); dispatch remains closed at ${path}`);
+    };
+    return { path, generation: owner.generation, assertOwned, release: async (keepBlocked = false) => {
+            assertOwned();
+            if (keepBlocked) {
+                // A caught failure can be retried even while this embedding process stays alive.
+                await symlink(JSON.stringify({ ...identity(), released: true }), join(directory, `next-${owner.generation}`));
+            }
+            else {
+                // A live owner cannot be reclaimed; unlink only while we still own this exact generation.
+                await unlink(path);
+                await rm(directory, { recursive: true });
+            }
+        } };
+}
+export async function acquireWorkerWriteLock(project, block = false, proposalDigest) {
+    const path = workerWriteLock(project);
+    const owner = { ...identity(), ...(proposalDigest ? { proposalDigest } : {}) };
+    const directory = `${path}.${owner.generation}`;
+    await mkdir(dirname(path), { recursive: true });
+    await sweepOrphanedOwners(path);
+    await mkdir(directory);
+    try {
+        await writeFile(join(directory, 'owner.json'), JSON.stringify(owner), { mode: 0o600 });
+        if (block)
+            await writeFile(join(directory, 'blocked'), 'Worker policy apply/recovery in progress.\n', { mode: 0o600 });
+        // No visible lock can exist without an owner, even if initialization is interrupted.
+        await symlink(basename(directory), path);
+    }
+    catch (error) {
+        await rm(directory, { recursive: true, force: true });
+        if (error.code === 'EEXIST')
+            throw new Error(`Worker configuration is locked: ${path}; use authorized recovery after its owner exits`);
+        throw error;
+    }
+    return lease(path, directory, owner);
+}
+export async function reclaimWorkerWriteLock(project) {
+    const path = workerWriteLock(project);
+    let directory;
+    let previous;
+    try {
+        directory = resolve(dirname(path), await readlink(path));
+        previous = latest(directory);
+    }
+    catch (error) {
+        if (missing(error))
+            throw new Error(`No interrupted apply; nothing to recover at ${path}`);
+        throw error;
+    }
+    if (!provablyDead(previous))
+        throw new Error(`Worker configuration is locked by a live or unverifiable owner (${previous.host}:${previous.pid}); ${path}`);
+    const owner = identity();
+    try {
+        await symlink(JSON.stringify(owner), join(directory, `next-${previous.generation}`));
+    }
+    catch (error) {
+        if (error.code === 'EEXIST')
+            throw new Error(`Worker configuration is locked: another recovery claimed generation ${previous.generation}`);
+        throw error;
+    }
+    const result = lease(path, directory, owner);
+    result.assertOwned();
+    await writeFile(join(directory, 'blocked'), 'Worker policy recovery in progress.\n', { mode: 0o600 });
+    return result;
+}
+//# sourceMappingURL=worker-owner-lock.js.map

package/dist/src/config/worker-parallelism.js

@@ -0,0 +1,154 @@
+// Defines and validates direct worker parallelism configuration before use.
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { readFileSync, existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { PROVIDER_IDS } from '../providers/provider-definitions.js';
+import { isCanonicalWorkerModelKey, loadProviderModelCapabilities, resolveWorkerInstallation } from '../models/provider-policy.js';
+import { resolveDispatchHostThresholds } from './dispatch-thresholds-runtime.mjs';
+import { expandWorkerGroupTemplates } from './worker-group-templates.js';
+let parallelismValidator;
+/** Offline shape and declaration validation. Qualification is checked at use time. */
+export function validateParallelismConfig(value) {
+    if (value === undefined)
+        return [];
+    const raw = value;
+    const expansion = expandWorkerGroupTemplates(value);
+    if (expansion.errors.length)
+        return expansion.errors;
+    value = expansion.parallelism;
+    if (!parallelismValidator) {
+        const here = dirname(fileURLToPath(import.meta.url));
+        const candidates = [resolve(here, '../../vscode-extension/schemas/aiwg.config.v1.json'), resolve(here, '../../../vscode-extension/schemas/aiwg.config.v1.json')];
+        const file = candidates.find(existsSync);
+        if (!file)
+            throw new Error('Parallelism schema is unavailable');
+        const schema = JSON.parse(readFileSync(file, 'utf8'));
+        const ajv = addFormats(new Ajv({ strict: true, allErrors: true }));
+        parallelismValidator = ajv.compile({ ...schema.properties.parallelism, definitions: schema.definitions });
+    }
+    if (!parallelismValidator(raw))
+        return (parallelismValidator.errors ?? []).map(error => `OG_CONFIG_REFERENCE /parallelism${error.instancePath}: ${error.message}`);
+    if (!parallelismValidator(value))
+        return (parallelismValidator.errors ?? []).map(error => `OG_CONFIG_REFERENCE /parallelism${error.instancePath}: ${error.message}`);
+    const policy = value;
+    const errors = [];
+    const error = (pointer, message) => { errors.push(`OG_CONFIG_REFERENCE /parallelism/${pointer}: ${message}`); };
+    const builtinIds = new Set(PROVIDER_IDS.filter(id => id !== 'generic'));
+    for (const [id, installation] of Object.entries(policy.clis ?? {})) {
+        if (installation.adapter.startsWith('providers:') && !builtinIds.has(installation.adapter.slice(10)))
+            error(`clis/${id}/adapter`, 'Unknown provider binding');
+    }
+    for (const [id, group] of Object.entries(policy.groups ?? {})) {
+        if (group.execution?.launchMode === 'native-sandbox'
+            && (!['read-only', 'workspace-write'].includes(group.execution.sandbox ?? '')
+                || (group.execution.transport ?? 'shell') !== 'shell')) {
+            error(`groups/${id}/execution/launchMode`, 'native-sandbox requires an enforcing read-only or workspace-write shell sandbox');
+        }
+        if (group.execution?.launchMode === 'native-sandbox') {
+            if (group.execution.approval === 'on-request')
+                error(`groups/${id}/execution/approval`, 'native-sandbox requires approval="never"');
+            if (group.execution.network === 'allowlisted')
+                error(`groups/${id}/execution/network`, 'native-sandbox requires network="deny"');
+        }
+        const ids = new Set();
+        for (const member of (group.members ?? [])) {
+            if (ids.has(member.id))
+                error(`groups/${id}/members`, 'Duplicate member ID');
+            ids.add(member.id);
+            if (!policy.clis?.[member.cli] && !builtinIds.has(member.cli))
+                error(`groups/${id}/members/${member.id}/cli`, 'Unknown installation');
+            if (group.execution?.launchMode === 'native-sandbox'
+                && (policy.clis?.[member.cli]?.adapter ?? `providers:${member.cli}`) !== 'providers:codex') {
+                error(`groups/${id}/members/${member.id}/cli`, 'native-sandbox requires a codex adapter');
+            }
+        }
+        for (const member of group.fallback ?? [])
+            if (!ids.has(member))
+                error(`groups/${id}/fallback`, 'Unknown fallback member');
+        for (const role of group.requiredRoles ?? []) {
+            if (!(group.members ?? []).some(m => m.enabled !== false && policy.clis?.[m.cli]?.enabled !== false && m.roles.includes(role)))
+                error(`groups/${id}/requiredRoles`, `No enabled member covers ${role}`);
+        }
+    }
+    const admission = policy.admission;
+    for (const group of Object.keys(admission?.groupCaps ?? {}))
+        if (!policy.groups?.[group])
+            error('admission/groupCaps', 'Unknown group');
+    for (const cli of Object.keys(admission?.cliCaps ?? {}))
+        if (!policy.clis?.[cli] && !builtinIds.has(cli))
+            error('admission/cliCaps', 'Unknown installation');
+    for (const key of Object.keys(admission?.memberCaps ?? {})) {
+        const [group, member, extra] = key.split('/');
+        if (extra !== undefined || !policy.groups?.[group]?.members?.some(m => m.id === member))
+            error('admission/memberCaps', 'Unknown group/member');
+    }
+    for (const key of Object.keys(admission?.modelCaps ?? {}))
+        if (!isCanonicalWorkerModelKey(key))
+            error('admission/modelCaps', 'Noncanonical inference model key');
+    if (admission?.hostResources !== undefined) {
+        try {
+            resolveDispatchHostThresholds(undefined, admission.hostResources);
+        }
+        catch (validation) {
+            error('admission/hostResources', validation instanceof Error ? validation.message : String(validation));
+        }
+    }
+    errors.push(...validateWorkerHealthConfig(policy.health));
+    return errors;
+}
+/** Cross-field health preferences are validated offline; controls are qualified at dispatch. */
+export function validateWorkerHealthConfig(health) {
+    if (health === undefined)
+        return [];
+    const errors = [];
+    const error = (field, message) => { errors.push(`OG_CONFIG_REFERENCE /parallelism/health/${field}: ${message}`); };
+    const checkSeconds = health.checkSeconds ?? 15;
+    if (checkSeconds > (health.startupSeconds ?? 60))
+        error('checkSeconds', 'Must not exceed startupSeconds');
+    if ((health.quietSeconds ?? 90) >= (health.stallSeconds ?? 300))
+        error('quietSeconds', 'Must be less than stallSeconds');
+    if ((health.cooldownSeconds ?? 120) > (health.maxCooldownSeconds ?? 900))
+        error('cooldownSeconds', 'Must not exceed maxCooldownSeconds');
+    for (const role of Object.keys(health.roleScale ?? {})) {
+        if (!['efficiency', 'coding', 'reasoning'].includes(role))
+            error('roleScale', `Unknown role ${role}`);
+    }
+    for (const field of ['modelScale', 'modelStartupSeconds']) {
+        for (const [key, value] of Object.entries(health[field] ?? {})) {
+            if (!isCanonicalWorkerModelKey(key))
+                error(field, 'Noncanonical inference model key');
+            if (field === 'modelStartupSeconds' && checkSeconds > value)
+                error(field, 'Model startup must cover checkSeconds');
+        }
+    }
+    return errors;
+}
+/** Resolve one enabled installation through trusted metadata, without probes.
+ * Implicit canonical IDs inherit current-account auth; no account/quota identity
+ * is invented. Profile qualification remains the invocation owner's obligation.
+ */
+export function resolveWorkerGroupInstallation(parallelism, installationId, registry = loadProviderModelCapabilities()) {
+    const errors = validateParallelismConfig(parallelism);
+    if (errors.length)
+        throw new Error(errors.join('; '));
+    if (!parallelism.worker_dispatch)
+        throw new Error('OG_CONFIG_REFERENCE /parallelism/worker_dispatch: Worker dispatch is disabled');
+    const explicit = parallelism.clis?.[installationId];
+    const installation = explicit
+        ? structuredClone(explicit)
+        : { adapter: `providers:${installationId}`, enabled: true };
+    if (!explicit && (!PROVIDER_IDS.includes(installationId) || installationId === 'generic')) {
+        throw new Error(`OG_CONFIG_REFERENCE /parallelism/clis/${installationId}: Unknown canonical installation`);
+    }
+    if (installation.enabled === false)
+        throw new Error(`OG_CONFIG_REFERENCE /parallelism/clis/${installationId}: Installation is disabled`);
+    try {
+        return { installation: { ...installation, enabled: true }, ...resolveWorkerInstallation(registry, installation) };
+    }
+    catch (error) {
+        throw new Error(`OG_ADAPTER_UNQUALIFIED /parallelism/clis/${installationId}: ${error}`);
+    }
+}
+//# sourceMappingURL=worker-parallelism.js.map

package/dist/src/config/worker-write.js

@@ -0,0 +1,75 @@
+// Shares atomic replacement and serialization across worker configuration owners.
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { mkdir, writeFile, rename, unlink, stat } from 'node:fs/promises';
+import { statSync, readFileSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { dirname, join } from 'node:path';
+import { acquireWorkerWriteLock, workerWriteLock } from './worker-owner-lock.js';
+export { acquireWorkerWriteLock, reclaimWorkerWriteLock, workerWriteLock } from './worker-owner-lock.js';
+const maintenance = new AsyncLocalStorage();
+export const runWorkerMaintenance = (body) => maintenance.run(true, body);
+export const isWorkerMaintenance = () => maintenance.getStore() === true;
+export function workerDispatchBlocked(project) {
+    try {
+        statSync(join(workerWriteLock(project), 'blocked'));
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+export async function atomicConfigWrite(file, content, assertOwned) {
+    assertOwned?.();
+    await mkdir(dirname(file), { recursive: true });
+    const temporary = `${file}.${randomBytes(6).toString('hex')}.tmp`;
+    let mode = 0o600;
+    try {
+        mode = (await stat(file)).mode;
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    try {
+        assertOwned?.();
+        await writeFile(temporary, content, { encoding: 'utf8', mode });
+        assertOwned?.();
+        await rename(temporary, file);
+    }
+    finally {
+        await unlink(temporary).catch(error => { if (error.code !== 'ENOENT')
+            throw error; });
+    }
+}
+export function workerRecoveryDiagnostic(project) {
+    const record = join(workerWriteLock(project), 'recovery.json');
+    let digest = 'sha256:<original-proposal-digest>';
+    try {
+        const retained = JSON.parse(readFileSync(record, 'utf8')).proposal?.digest;
+        if (typeof retained === 'string')
+            digest = retained;
+    }
+    catch {
+        try {
+            const retained = JSON.parse(readFileSync(join(workerWriteLock(project), 'owner.json'), 'utf8')).proposalDigest;
+            if (typeof retained === 'string')
+                digest = retained;
+        }
+        catch { /* Legacy or unreadable records require the retained review's digest. */ }
+    }
+    const quote = (value) => `'${value.replace(/'/g, "'\\''")}'`;
+    return `Worker dispatch is closed for project ${project}; recovery record: ${record}. Recover with: aiwg config set --project --target ${quote(project)} --recover --authorize ${quote(digest)}`;
+}
+export async function withWorkerWriteLock(project, body) {
+    const lock = await acquireWorkerWriteLock(project);
+    try {
+        lock.assertOwned();
+        return await body();
+    }
+    finally {
+        await lock.release();
+    }
+}
+//# sourceMappingURL=worker-write.js.map

package/dist/src/decision/telemetry/exporter.js

@@ -63,7 +63,8 @@ export class BoundedDecisionTraceExporter {
                     await Promise.race([this.sink.export(trace, controller.signal), deadline]);
                 }
                 catch (error) {
-                    this.record(controller.signal.aborted ? 'timeout' : 'failed', error instanceof Error ? error.message : 'export failed');
+                    this.record(controller.signal.aborted ? 'timeout' : 'failed', this.options.redactErrors
+                        ? 'telemetry export failed' : error instanceof Error ? error.message : 'export failed');
                 }
                 finally {
                     if (timeout)

package/dist/src/decision/telemetry/index.js

@@ -10,4 +10,5 @@ export * from './retention.js';
 export * from './runtime.js';
 export * from './trace.js';
 export * from './types.js';
+export * from './worker.js';
 //# sourceMappingURL=index.js.map

package/dist/src/decision/telemetry/mapping.js

@@ -1,4 +1,47 @@
 import { sanitizeOpaqueValue } from './redaction.js';
+import { createHash } from 'node:crypto';
+import { GEN_AI_SEMCONV_REVISION } from './types.js';
+/** Correlation is opaque on export, including when hostile content is planted in an ID. */
+function workerCorrelation(value) {
+    return typeof value === 'string' && value.length > 0 && value.length <= 1024
+        ? createHash('sha256').update(value).digest('hex') : null;
+}
+/** Only operator-listed model names, fixed enums and finite numbers leave this mapping. */
+export function mapWorkerReceipt(receipt, correlation, allowedModels = []) {
+    const out = { attributes: {}, provenance: {} };
+    const model = (value) => typeof value === 'string' && value.length <= 128
+        && /^[a-zA-Z0-9][a-zA-Z0-9._:/-]*$/.test(value)
+        && !/(?:sk[-_]|gh[pousr]_|github_pat_|AKIA|bearer|secret|password)/i.test(value)
+        && allowedModels.includes(value) ? value : null;
+    const confidence = ['unavailable', 'runtime-configured-only', 'backend-attested'].includes(String(receipt.identityConfidence))
+        ? String(receipt.identityConfidence) : 'unavailable';
+    const observed = confidence === 'unavailable' ? null : model(receipt.observed?.model);
+    const observedProvenance = observed === null ? 'unknown' : confidence === 'backend-attested' ? 'provider-fact' : 'client-derived';
+    const quality = receipt.usage?.quality === 'reported' || receipt.usage?.quality === 'estimated' ? receipt.usage.quality : 'unknown';
+    const usageProvenance = quality === 'reported' ? 'provider-fact' : quality === 'estimated' ? 'estimate' : 'unknown';
+    put(out, 'aiwg.otel.gen_ai_semconv_revision', GEN_AI_SEMCONV_REVISION, 'client-derived');
+    for (const [key, value] of Object.entries({ 'aiwg.conductor.id': correlation.conductorId,
+        'aiwg.run.id': correlation.runId, 'aiwg.task.id': receipt.taskId, 'aiwg.invocation.id': receipt.invocationId })) {
+        put(out, key, workerCorrelation(value), 'client-derived');
+    }
+    put(out, 'aiwg.worker.transport', receipt.transport === 'shell' || receipt.transport === 'mcp' ? receipt.transport : null, 'client-derived');
+    put(out, 'aiwg.worker.termination', receipt.termination === 'confirmed' || receipt.termination === 'uncertain' ? receipt.termination : null, 'client-derived');
+    put(out, 'aiwg.worker.identity_confidence', confidence, 'client-derived');
+    put(out, 'gen_ai.request.model', model(receipt.requested?.model), 'client-derived');
+    put(out, 'gen_ai.response.model', observed, observedProvenance);
+    put(out, 'aiwg.worker.observed_model_provenance', observedProvenance, 'client-derived');
+    put(out, 'aiwg.usage.quality', quality, 'client-derived');
+    for (const [key, value] of [['input_tokens', receipt.usage?.inputTokens], ['output_tokens', receipt.usage?.outputTokens]]) {
+        const count = quality !== 'unknown' && typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null;
+        put(out, `gen_ai.usage.${key}`, count, usageProvenance);
+        put(out, `aiwg.usage.${key}_provenance`, count === null ? 'unknown' : usageProvenance, 'client-derived');
+    }
+    const cost = receipt.usage?.costUsd;
+    const knownCost = quality !== 'unknown' && typeof cost === 'number' && Number.isFinite(cost) && cost >= 0 ? cost : null;
+    put(out, 'aiwg.usage.cost_usd', knownCost, usageProvenance);
+    put(out, 'aiwg.usage.cost_provenance', knownCost === null ? 'unknown' : usageProvenance, 'client-derived');
+    return out;
+}
 function put(target, key, value, provenance) {
     target.attributes[key] = value;
     target.provenance[key] = value === null ? 'unknown' : provenance;

package/dist/src/decision/telemetry/otlp-http.js

@@ -28,7 +28,8 @@ export class DecisionOtlpHttpSink {
     }
     async export(trace, signal) {
         const safe = sanitizedTelemetryExport(trace);
-        const payload = JSON.stringify({ resourceSpans: [{ scopeSpans: [{ scope: { name: 'aiwg.decision', version: '1' },
+        const payload = JSON.stringify({ resourceSpans: [{ scopeSpans: [{ ...(safe.schemaUrl ? { schemaUrl: safe.schemaUrl } : {}),
+                            scope: { name: safe.spans.every(span => span.name === 'worker.attempt') ? 'aiwg.worker' : 'aiwg.decision', version: '1' },
                             spans: safe.spans.map(toOtlpSpan) }] }] });
         if (Buffer.byteLength(payload, 'utf8') > this.maxPayloadBytes)
             throw new Error('OTLP payload exceeds configured bound');
@@ -172,7 +173,9 @@ function toOtlpSpan(span) {
         name: span.name,
         startTimeUnixNano: String(Math.trunc(span.startTimeUnixMs * 1_000_000)),
         endTimeUnixNano: String(Math.trunc(span.endTimeUnixMs * 1_000_000)),
-        attributes: Object.entries(span.attributes).map(([key, value]) => toOtlpAttribute(key, value)),
+        // GenAI unknowns have no measurement; never serialize a token count as zero or a string.
+        attributes: Object.entries(span.attributes).filter(([key, value]) => value !== null || !key.startsWith('gen_ai.'))
+            .map(([key, value]) => toOtlpAttribute(key, value)),
         links: span.links.map(link => ({ traceId: link.traceId, spanId: link.spanId,
             attributes: Object.entries(link.attributes ?? {}).map(([key, value]) => toOtlpAttribute(key, value)) })),
         events: span.events.map(event => ({ name: event.name, timeUnixNano: String(Math.trunc(event.timeUnixMs * 1_000_000)),

package/dist/src/decision/telemetry/redaction.js

@@ -5,6 +5,10 @@ const SAFE_EVENT_NAMES = new Set(['retry.scheduled', 'attempt.terminated', 'brea
 // plausible custom key can still carry body text or PII in its value.
 const SAFE_ATTRIBUTE_KEYS = new Set(`
   aiwg.run.id aiwg.invocation.id aiwg.workflow.status aiwg.evaluation.count
+  aiwg.conductor.id aiwg.task.id aiwg.worker.transport aiwg.worker.identity_confidence
+  aiwg.worker.termination aiwg.otel.gen_ai_semconv_revision aiwg.usage.quality
+  aiwg.usage.input_tokens_provenance aiwg.usage.output_tokens_provenance
+  aiwg.worker.observed_model_provenance
   aiwg.decision.id aiwg.decision.version aiwg.decision.alias aiwg.decision.status aiwg.decision.reason
   aiwg.ruleset.id aiwg.ruleset.version aiwg.binding.id aiwg.binding.version
   aiwg.adapter.id aiwg.adapter.version aiwg.attempt.ordinal aiwg.attempt.count
@@ -39,7 +43,8 @@ for (const prefix of ['aiwg.definition', 'aiwg.policy', 'aiwg.calibration']) {
 // Declared keys whose names match PROTECTED_KEY but carry only fixed metadata.
 // `aiwg.link.state` is the deletion tombstone marker; dropping it would turn an
 // explicit tombstone into an unexplained link in exports.
-const PROTECTED_KEY_EXEMPTIONS = new Set(['gen_ai.response.model', 'http.response.status_code', 'aiwg.link.state']);
+const PROTECTED_KEY_EXEMPTIONS = new Set(['gen_ai.response.model', 'http.response.status_code', 'aiwg.link.state',
+    'aiwg.usage.input_tokens_provenance', 'aiwg.usage.output_tokens_provenance']);
 export const DEFAULT_ATTRIBUTE_VALUE_LIMIT = 256;
 export function sanitizeOpaqueValue(value, maximum = DEFAULT_ATTRIBUTE_VALUE_LIMIT) {
     return value.replace(CONTROL, '').slice(0, maximum);

package/dist/src/decision/telemetry/types.js

@@ -1,3 +1,6 @@
 /** OpenTelemetry-compatible, dependency-free decision telemetry contract. */
 export const DECISION_TELEMETRY_SCHEMA_VERSION = 'decision-telemetry/v1';
+/** Adopted GenAI attributes from semantic-conventions v1.37.0 (development). */
+export const GEN_AI_SEMCONV_REVISION = '1.37.0';
+export const GEN_AI_SCHEMA_URL = `https://opentelemetry.io/schemas/${GEN_AI_SEMCONV_REVISION}`;
 //# sourceMappingURL=types.js.map

package/dist/src/decision/telemetry/worker.js

@@ -0,0 +1,69 @@
+import { createTelemetryContext, extractTraceContext } from './context.js';
+import { BoundedDecisionTraceExporter } from './exporter.js';
+import { mapWorkerReceipt } from './mapping.js';
+import { DECISION_TELEMETRY_SCHEMA_VERSION, GEN_AI_SCHEMA_URL } from './types.js';
+/** Optional observer for attempts sharing one task policy; retains no receipts or completion state. */
+export class WorkerReceiptTelemetry {
+    exporter;
+    options;
+    root;
+    constructor(options) {
+        this.options = structuredClone({ ...options, sink: undefined });
+        this.root = createTelemetryContext();
+        if (options.enabled === true && options.sink) {
+            this.exporter = new BoundedDecisionTraceExporter(options.sink, {
+                capacity: options.capacity ?? 32, timeoutMs: options.timeoutMs ?? 1000,
+                maximumTraceBytes: options.maximumTraceBytes, maximumDiagnostics: options.maximumDiagnostics,
+                canaries: options.canaries, redactErrors: true,
+            });
+        }
+    }
+    get diagnostics() { return this.exporter?.diagnostics ?? []; }
+    /** Gate before mapping or enqueue. Unknown policy and local-only tasks suppress all export. */
+    offer(receipt, timing) {
+        try {
+            if (!this.exporter || !this.externalExportAllowed())
+                return false;
+            const now = Date.now();
+            const start = timing?.startTimeUnixMs ?? now;
+            const end = timing?.endTimeUnixMs ?? now;
+            if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start)
+                return false;
+            const parent = this.options.parent;
+            const safeParent = parent ? extractTraceContext({ traceparent: `00-${parent.traceId}-${parent.spanId}-${parent.traceFlags}` }) : null;
+            if (parent && !safeParent)
+                return false;
+            const context = createTelemetryContext(undefined, safeParent ?? this.root);
+            const mapped = mapWorkerReceipt(receipt, this.options, this.options.allowedModels);
+            const span = {
+                schemaVersion: DECISION_TELEMETRY_SCHEMA_VERSION, name: 'worker.attempt', context,
+                parentSpanId: safeParent?.spanId ?? null, startTimeUnixMs: start, endTimeUnixMs: end,
+                // A confirmed stop is not proof of acceptance or success.
+                status: 'unset', attributes: mapped.attributes, provenance: mapped.provenance, links: [],
+                events: [{ name: 'attempt.terminated', timeUnixMs: end, attributes: {
+                            'aiwg.worker.termination': mapped.attributes['aiwg.worker.termination'] ?? null,
+                        } }],
+            };
+            return this.exporter.offer({ schemaVersion: DECISION_TELEMETRY_SCHEMA_VERSION,
+                schemaUrl: GEN_AI_SCHEMA_URL, traceId: context.traceId, spans: [span] });
+        }
+        catch {
+            return false;
+        }
+    }
+    async shutdown() { await this.exporter?.shutdown(); }
+    externalExportAllowed() {
+        const selection = this.options.selection;
+        if (!selection?.dataPolicy?.allowedProcessing?.includes('remote'))
+            return false;
+        if (this.options.dataClass !== undefined) {
+            if (!selection.dataClasses || !Object.hasOwn(selection.dataClasses, this.options.dataClass))
+                return false;
+            const narrowed = selection.dataClasses?.[this.options.dataClass];
+            if (!narrowed || (narrowed.allowedProcessing !== undefined && !narrowed.allowedProcessing.includes('remote')))
+                return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=worker.js.map

package/dist/src/lint/rule-activation.js

@@ -1,11 +1,14 @@
 /** Activation checks within the existing lint runner, not a delivery selector. */
 import fs from 'node:fs';
 import path from 'node:path';
-import { loadLocalCapabilityEntries, resolveRuleBindingTarget } from '../artifacts/query-engine.js';
+import { BUILTIN_GRAPH_CONFIGS } from '../artifacts/types.js';
+import { resolveRuleBindingTarget } from '../artifacts/query-engine.js';
+import { collectRuleBindingEntries } from '../artifacts/index-builder.js';
+import { resolveFrameworkIndexRoot } from '../artifacts/framework-index-paths.js';
 import { parseRuleFrontmatter, RULE_BINDING_TYPES, coreBodyPath, validateCoreBody } from '../rules/activation.mjs';
 export const ruleActivationRuleset = {
     id: 'rule-activation', name: 'Rule activation', framework: 'core', version: '1.0.0',
-    description: 'Validate rule and behavior activation contracts and exact indexed bindings',
+    description: 'Validate rule and behavior activation contracts and exact source bindings',
     rules: [{
             id: 'rules/activation', name: 'Rule activation contract', severity: 'error',
             description: 'Validate activation, summaries, paths, bindings, and migration fallback',
@@ -13,7 +16,14 @@ export const ruleActivationRuleset = {
             checks: [{ type: 'rule-activation' }],
         }],
 };
-export function lintRuleActivation(content, file, projectRoot, entries, absolutePath) {
+/** Load the index builder's canonical binding metadata without reading or writing an index. */
+export async function loadRuleActivationEntries(projectRoot) {
+    const root = resolveFrameworkIndexRoot(projectRoot);
+    const snapshots = await Promise.all(BUILTIN_GRAPH_CONFIGS.framework.scanDirs.map(scope => collectRuleBindingEntries(root, scope)));
+    return snapshots.flat();
+}
+/** Validate one rule against the source snapshot supplied by the lint runner. */
+export function lintRuleActivation(content, file, projectRoot, entries = [], absolutePath) {
     // Directory documentation and generated indexes are not authored rules.
     if (/^(?:README|RULES-INDEX|RULES-ONDEMAND)\.md$/.test(file.split('/').pop()))
         return [];
@@ -39,13 +49,11 @@ export function lintRuleActivation(content, file, projectRoot, entries, absolute
     const bindings = result.rule.bound_to;
     if (!Object.values(bindings).some(list => list.length > 0))
         return diagnostics;
-    // Reuse existing artifact index ownership and show precedence. No title guessing,
-    // corpus directory resolver, or extra binding registry.
-    const indexed = entries ?? loadLocalCapabilityEntries(projectRoot);
+    // Preserve exact identities and show precedence using current source metadata.
     for (const key of Object.keys(RULE_BINDING_TYPES)) {
         for (const id of bindings[key]) {
             try {
-                resolveRuleBindingTarget(indexed, RULE_BINDING_TYPES[key], id);
+                resolveRuleBindingTarget(entries, RULE_BINDING_TYPES[key], id);
             }
             catch (error) {
                 diagnostics.push({ ruleId: 'rules/activation', ruleName: 'Rule activation contract',

package/dist/src/lint/runner.js

@@ -7,7 +7,7 @@
  * @issue #810
  */
 import fs from 'fs';
-import { lintRuleActivation } from './rule-activation.js';
+import { lintRuleActivation, loadRuleActivationEntries } from './rule-activation.js';
 import { guardRulesInlineBudget } from '../rules/inline-budget.mjs';
 import { dropGitignored } from '../config/gitignore.js';
 import fsp from 'fs/promises';
@@ -563,7 +563,7 @@ async function runRule(rule, targetDir, allFiles, referenceIndex, projectRoot, a
             if (check.type === 'id-unique')
                 continue; // Already handled
             if (check.type === 'rule-activation') {
-                diagnostics.push(...lintRuleActivation(content, file, projectRoot, artifactEntries, absPath));
+                diagnostics.push(...lintRuleActivation(content, file, projectRoot, artifactEntries ??= await loadRuleActivationEntries(projectRoot), absPath));
                 continue;
             }
             const checkDiagnostics = runCheck(check, content, frontmatter, file, targetDir, allFiles, referenceIndex, projectRoot);