@aiwg/cli 2026.8.11 → 2026.8.12

package/bin/aiwg.mjs

@@ -124,6 +124,8 @@ const FAST_HELP_TEXT = `
 
   VALIDATION
     validate-metadata [path]     Validate AIWG component metadata (defaults to agentic/code)
+    verify <artifact>            Verify DSSE provenance using an explicit versioned trust root
+    verify trust <action>        Bootstrap, update, or inspect artifact trust state
     context-firewall [scan]      Audit provider context, trust, drift, poisoning signals, and budget
     context-firewall baseline    Plan or explicitly write the reviewed context baseline
 

package/dist/src/api/index.d.ts

@@ -10,4 +10,10 @@ export * from '../resources/index.js';
 export * from '../sessions/index.js';
 export * from '../memory/index.js';
 export * from '../security/threat-assessment-config.js';
+export * from '../security/artifact-verifier.js';
+export * from '../security/artifact-attestation.js';
+export * from '../providers/transformation-receipt.js';
+export * from '../providers/transformation-receipt-integration.js';
+export * from '../marketplace/artifact-attestation.js';
+export { ARTIFACT_TRUST_ROOT_MEDIA_TYPE, ARTIFACT_TRUST_ROOT_SCHEMA_VERSION, ARTIFACT_TRUST_STATE_SCHEMA_VERSION, bootstrapTrustRoot, parseTrustRoot, parseTrustState, readTrustState, validateTrustRoot, validateTrustState, verifyRootTransition, writeTrustState, channelStateKey, canonicalJson, dssePae, publicKeyFingerprint, sha256, type ArtifactTrustRoot, type ArtifactTrustState, type RootBootstrapResult, type RootTransitionResult, type ArtifactTrustPolicySettings, type TrustedChannelState, } from '../security/artifact-trust.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/api/index.js

@@ -10,4 +10,10 @@ export * from '../resources/index.js';
 export * from '../sessions/index.js';
 export * from '../memory/index.js';
 export * from '../security/threat-assessment-config.js';
+export * from '../security/artifact-verifier.js';
+export * from '../security/artifact-attestation.js';
+export * from '../providers/transformation-receipt.js';
+export * from '../providers/transformation-receipt-integration.js';
+export * from '../marketplace/artifact-attestation.js';
+export { ARTIFACT_TRUST_ROOT_MEDIA_TYPE, ARTIFACT_TRUST_ROOT_SCHEMA_VERSION, ARTIFACT_TRUST_STATE_SCHEMA_VERSION, bootstrapTrustRoot, parseTrustRoot, parseTrustState, readTrustState, validateTrustRoot, validateTrustState, verifyRootTransition, writeTrustState, channelStateKey, canonicalJson, dssePae, publicKeyFingerprint, sha256, } from '../security/artifact-trust.js';
 //# sourceMappingURL=index.js.map

package/dist/src/cli/handlers/artifact-verify.js

@@ -0,0 +1,171 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { bootstrapTrustRoot, parseTrustState, verifyRootTransition, writeTrustState, } from '../../security/artifact-trust.js';
+import { verifyArtifact } from '../../security/artifact-verifier.js';
+const MAX_BYTES = 32 * 1024 * 1024;
+const DEFAULT_STATE = '.aiwg/security/artifact-trust-state.json';
+function usage() {
+    return [
+        'aiwg verify — Verify cross-asset provenance using explicit trust policy',
+        '',
+        'Usage:',
+        '  aiwg verify <artifact> --attestation <file-or-https-url> --policy <root.json>',
+        '      [--state <file>] [--root-fingerprint <sha256>] [--material <uri>=<file>]...',
+        '      [--asset-type <type> --namespace <name> --channel <name>]',
+        '      [--offline] [--json] [--allow-policy-exempt] [--no-write-state]',
+        '  aiwg verify trust bootstrap --root <file> --fingerprint <sha256> [--state <file>]',
+        '  aiwg verify trust update --current <file> --next <file> [--state <file>]',
+        '  aiwg verify trust status [--state <file>] [--json]',
+        '',
+        'Trust is never inferred from DSSE keyid or embedded outer public keys.',
+    ].join('\n');
+}
+function valueAfter(args, flag) {
+    const index = args.indexOf(flag);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+function resolve(cwd, file) {
+    return path.isAbsolute(file) ? file : path.resolve(cwd, file);
+}
+function checkedRead(file) {
+    const bytes = readFileSync(file);
+    if (bytes.length > MAX_BYTES)
+        throw new Error(`${file} exceeds the ${MAX_BYTES}-byte safety limit`);
+    return bytes;
+}
+async function readLocation(location, cwd, offline, signal) {
+    if (!/^https?:\/\//i.test(location))
+        return checkedRead(resolve(cwd, location));
+    if (offline)
+        throw new Error('offline mode forbids network locations');
+    if (!location.startsWith('https://'))
+        throw new Error('remote verification inputs must use HTTPS');
+    const response = await fetch(location, { redirect: 'follow', signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(15_000)]) : AbortSignal.timeout(15_000) });
+    if (!response.ok || !response.url.startsWith('https://'))
+        throw new Error(`HTTPS input failed closed (${response.status})`);
+    const contentLength = Number(response.headers.get('content-length') ?? 0);
+    if (contentLength > MAX_BYTES)
+        throw new Error('remote input exceeds the safety limit');
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.length > MAX_BYTES)
+        throw new Error('remote input exceeds the safety limit');
+    return bytes;
+}
+function renderHuman(outcome) {
+    return [
+        `${outcome.status}: ${outcome.artifact.name}`,
+        `  SHA-256: ${outcome.artifact.sha256}`,
+        `  Policy: ${outcome.policy ?? 'unavailable'}`,
+        `  Identities: ${outcome.identities.join(', ') || 'none'}`,
+        `  Root version: ${outcome.rootVersion ?? 'unavailable'}`,
+        ...outcome.diagnostics.map(diagnostic => `  ${diagnostic.code}: ${diagnostic.message}`),
+    ].join('\n');
+}
+async function trustCommand(ctx) {
+    const action = ctx.args[1];
+    const stateFile = resolve(ctx.cwd, valueAfter(ctx.args, '--state') ?? DEFAULT_STATE);
+    if (action === 'status') {
+        if (!existsSync(stateFile))
+            return { exitCode: 1, message: `Trust state not found: ${stateFile}` };
+        const state = parseTrustState(checkedRead(stateFile));
+        return {
+            exitCode: 0,
+            message: ctx.args.includes('--json') ? JSON.stringify(state, null, 2) : `Root v${state.rootVersion} ${state.rootSha256}\nTrusted time: ${state.trustedTime}\nChannels: ${Object.keys(state.channels).length}`,
+            rawOutput: ctx.args.includes('--json'),
+        };
+    }
+    if (action === 'bootstrap') {
+        const rootFile = valueAfter(ctx.args, '--root');
+        const fingerprint = valueAfter(ctx.args, '--fingerprint');
+        if (!rootFile || !fingerprint)
+            return { exitCode: 1, message: 'trust bootstrap requires --root and --fingerprint' };
+        const bootstrapped = bootstrapTrustRoot(checkedRead(resolve(ctx.cwd, rootFile)), fingerprint);
+        writeTrustState(stateFile, bootstrapped.state);
+        return { exitCode: 0, message: `Bootstrapped trust root v${bootstrapped.root.signed.version} at ${stateFile}` };
+    }
+    if (action === 'update') {
+        const current = valueAfter(ctx.args, '--current');
+        const next = valueAfter(ctx.args, '--next');
+        if (!current || !next)
+            return { exitCode: 1, message: 'trust update requires --current and --next' };
+        if (!existsSync(stateFile))
+            return { exitCode: 1, message: `Trust state not found: ${stateFile}` };
+        const transition = verifyRootTransition(checkedRead(resolve(ctx.cwd, current)), checkedRead(resolve(ctx.cwd, next)), parseTrustState(checkedRead(stateFile)));
+        writeTrustState(stateFile, transition.state);
+        return { exitCode: 0, message: `Updated trust root to v${transition.state.rootVersion} at ${stateFile}` };
+    }
+    return { exitCode: 1, message: usage() };
+}
+export const artifactVerifyHandler = {
+    id: 'verify',
+    name: 'Artifact Verification',
+    description: 'Verify cross-asset DSSE provenance and manage trust roots',
+    category: 'utility',
+    aliases: [],
+    async execute(ctx) {
+        if (ctx.args.includes('--help') || ctx.args.includes('-h') || ctx.args.length === 0)
+            return { exitCode: 0, message: usage() };
+        try {
+            if (ctx.args[0] === 'trust')
+                return await trustCommand(ctx);
+            const artifactLocation = ctx.args[0];
+            const rootFile = valueAfter(ctx.args, '--policy');
+            if (!rootFile)
+                return { exitCode: 1, message: `--policy <root.json> is required\n\n${usage()}` };
+            const offline = ctx.args.includes('--offline');
+            const attestationLocation = valueAfter(ctx.args, '--attestation') ?? `${artifactLocation}.aiwg-attestation.json`;
+            const [artifactBytes, attestationBytes] = await Promise.all([
+                readLocation(artifactLocation, ctx.cwd, offline, ctx.signal),
+                readLocation(attestationLocation, ctx.cwd, offline, ctx.signal),
+            ]);
+            const rootBytes = checkedRead(resolve(ctx.cwd, rootFile));
+            const stateFile = resolve(ctx.cwd, valueAfter(ctx.args, '--state') ?? DEFAULT_STATE);
+            let state = existsSync(stateFile) ? parseTrustState(checkedRead(stateFile)) : undefined;
+            if (!state && !offline) {
+                const fingerprint = valueAfter(ctx.args, '--root-fingerprint');
+                if (fingerprint)
+                    state = bootstrapTrustRoot(rootBytes, fingerprint).state;
+            }
+            const materials = new Map();
+            for (let index = 0; index < ctx.args.length; index += 1) {
+                if (ctx.args[index] !== '--material')
+                    continue;
+                const spec = ctx.args[index + 1] ?? '';
+                const separator = spec.lastIndexOf('=');
+                if (separator <= 0)
+                    throw new Error('--material must use <uri>=<file>');
+                materials.set(spec.slice(0, separator), checkedRead(resolve(ctx.cwd, spec.slice(separator + 1))));
+            }
+            const outcome = await verifyArtifact({
+                artifactBytes,
+                artifactName: /^https:\/\//.test(artifactLocation) ? new URL(artifactLocation).pathname.split('/').pop() ?? artifactLocation : path.basename(artifactLocation),
+                attestation: JSON.parse(attestationBytes.toString('utf8')),
+                rootBytes,
+                state,
+                materials,
+                ...(valueAfter(ctx.args, '--asset-type') && valueAfter(ctx.args, '--namespace') && valueAfter(ctx.args, '--channel')
+                    ? { expectedScope: {
+                            assetType: valueAfter(ctx.args, '--asset-type'),
+                            namespace: valueAfter(ctx.args, '--namespace'),
+                            channel: valueAfter(ctx.args, '--channel'),
+                        } }
+                    : {}),
+                offline,
+            });
+            if (outcome.status === 'verified' && outcome.nextState && !ctx.args.includes('--no-write-state'))
+                writeTrustState(stateFile, outcome.nextState);
+            const json = ctx.args.includes('--json');
+            const processExit = outcome.status === 'policy-exempt' && ctx.args.includes('--allow-policy-exempt') ? 0 : outcome.exitCode;
+            return { exitCode: processExit, message: json ? JSON.stringify(outcome, null, 2) : renderHuman(outcome), rawOutput: json };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { exitCode: 27, message: ctx.args.includes('--json') ? JSON.stringify({
+                    schemaVersion: 'aiwg.verify.result.v1', status: 'malformed', exitCode: 27,
+                    artifact: { name: ctx.args[0] ? path.basename(ctx.args[0]) : 'unknown', sha256: '0'.repeat(64) },
+                    identities: [], diagnostics: [{ code: 'CLI_INPUT_ERROR', message }],
+                }, null, 2) : `malformed: ${message}`, rawOutput: ctx.args.includes('--json') };
+        }
+    },
+};
+//# sourceMappingURL=artifact-verify.js.map

package/dist/src/cli/handlers/index.js

@@ -61,12 +61,13 @@ import { versionsHandler } from './resource-versions.js';
 import { jobHandler } from './job.js';
 import { costReportHandler } from './cost-report.js';
 import { evidenceHandler } from './evidence.js';
+import { artifactVerifyHandler } from './artifact-verify.js';
 // Re-export individual handlers
 export { 
 // Maintenance
 helpHandler, versionHandler, authHandler, doctorHandler, contextFirewallHandler, updateHandler, refreshHandler, regenerateHandler, workspaceContextHandler, 
 // Framework management
-useHandler, listHandler, removeHandler, promoteHandler, installHandler, packagesHandler, marketplaceHandler, initHandler, setupHandler, setupGenerateHandler, setupRunHandler, setupValidateHandler, issueHandler, issueAuditHandler, runHandler, jobHandler, costReportHandler, evidenceHandler, 
+useHandler, listHandler, removeHandler, promoteHandler, installHandler, packagesHandler, marketplaceHandler, initHandler, setupHandler, setupGenerateHandler, setupRunHandler, setupValidateHandler, issueHandler, issueAuditHandler, runHandler, jobHandler, costReportHandler, evidenceHandler, artifactVerifyHandler, 
 // Project
 newBundleHandler, quickrefHandler, newProjectHandler, sessionHandler, sessionsHandler, 
 // Workspace
@@ -148,6 +149,7 @@ export const allHandlers = [
     jobHandler,
     costReportHandler,
     evidenceHandler,
+    artifactVerifyHandler,
     // Workspace management
     ...workspaceHandlers,
     // Subcommand handlers (MCP, catalog, index, skills)

package/dist/src/cli/handlers/setup-manifest.js

@@ -4,6 +4,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { parseDocument, stringify } from 'yaml';
 import { findPackageRoot } from '../find-package-root.js';
+import { sha256 } from '../../security/artifact-trust.js';
+import { artifactVerifyHandler } from './artifact-verify.js';
 const SETUP_SCHEMA_REL = 'agentic/code/addons/agentic-installer/schemas/v1/setup-manifest.schema.json';
 const GENERATE_HELP = `aiwg setup-generate - generate a starter setup.aiwg.io/v1 SetupManifest
 
@@ -40,7 +42,8 @@ Usage:
   aiwg setup-run [manifest-path] [--manifest PATH] [--dry-run] [--platform OS]
                  [--distro NAME] [--params-file PATH] [--param KEY=VALUE]
                  [--step STEP_ID] [--skip A,B] [--type user|developer|ci]
-                 [--yes|--confirm]
+                 [--yes|--confirm] [--attestation PATH] [--policy ROOT]
+                 [--state PATH] [--offline]
 
 Options:
   --manifest PATH      Manifest path. Defaults to ./setup.manifest.yaml.
@@ -53,11 +56,17 @@ Options:
   --skip A,B           Comma-separated step IDs to skip.
   --type TYPE          Select default manifest by install type when no path is given.
   --yes, --confirm     Explicitly authorize mutating step execution and recovery.
+  --attestation PATH   Adjacent AIWG attestation for provider-orchestrated handoff.
+  --policy ROOT        Explicit cross-asset trust root; required for agent handoff.
+  --state PATH         Persisted trust/freshness state used by verification.
+  --offline            Forbid network retrieval and require portable evidence.
   --help, -h           Show this help.
 
 Safety:
   setup-run always runs setup-validate before platform detection or execution.
   Mutating execution refuses to run without explicit confirmation.
+  Provider-orchestrated manifests are never handed to an agent unless their
+  exact bytes have status verified under the explicit trust policy.
 `;
 function flagValue(args, name) {
     for (let i = 0; i < args.length; i += 1) {
@@ -85,6 +94,12 @@ function positionalManifest(args) {
         '--type',
         '--output',
         '--name',
+        '--attestation',
+        '--policy',
+        '--state',
+        '--asset-type',
+        '--namespace',
+        '--channel',
     ]);
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
@@ -689,9 +704,17 @@ export function runSetupManifest(options) {
     }
     const manifest = validation.manifest;
     if (manifest.metadata.execution_mode === 'provider-orchestrated') {
+        const expectedDigest = sha256(readFileSync(validation.manifestPath));
+        if (options.artifactVerification?.status !== 'verified'
+            || options.artifactVerification.artifact.sha256 !== expectedDigest) {
+            return {
+                exitCode: 29,
+                message: 'setup-run: provider-orchestrated handoff blocked; verify these exact manifest bytes with an explicit trust root and adjacent attestation first',
+            };
+        }
         return {
             exitCode: 2,
-            message: 'setup-run: this manifest is provider-orchestrated; give its URL or contents to a supported AI provider instead of executing it as a deterministic CLI manifest',
+            message: `setup-run: verified provider-orchestrated manifest (${options.artifactVerification.artifact.sha256}); give these exact contents to a supported AI provider instead of executing them as a deterministic CLI manifest`,
         };
     }
     const target = detectPlatform(options);
@@ -801,7 +824,33 @@ export const setupRunHandler = {
             process.stdout.write(RUN_HELP);
             return { exitCode: 0 };
         }
-        return runSetupManifest(parseRunOptions(ctx));
+        const options = parseRunOptions(ctx);
+        const manifestPath = options.manifestPath ?? 'setup.manifest.yaml';
+        let artifactVerification;
+        if (flagValue(ctx.args, '--policy')) {
+            const verificationArgs = [
+                manifestPath,
+                '--attestation', flagValue(ctx.args, '--attestation') ?? `${manifestPath}.aiwg-attestation.json`,
+                '--policy', flagValue(ctx.args, '--policy'),
+                '--asset-type', flagValue(ctx.args, '--asset-type') ?? 'setup-manifest',
+                '--namespace', flagValue(ctx.args, '--namespace') ?? 'aiwg',
+                '--channel', flagValue(ctx.args, '--channel') ?? 'stable',
+                '--json',
+                ...(flagValue(ctx.args, '--state') ? ['--state', flagValue(ctx.args, '--state')] : []),
+                ...(hasFlag(ctx.args, '--offline') ? ['--offline'] : []),
+            ];
+            const verification = await artifactVerifyHandler.execute({ ...ctx, args: verificationArgs, rawArgs: verificationArgs });
+            try {
+                artifactVerification = JSON.parse(verification.message ?? '');
+            }
+            catch {
+                return { exitCode: verification.exitCode || 27, message: `setup-run: artifact verification failed: ${verification.message ?? 'invalid verifier output'}` };
+            }
+            if (artifactVerification.status !== 'verified') {
+                return { exitCode: artifactVerification.exitCode, message: `setup-run: provider handoff blocked by artifact verification status '${artifactVerification.status}'` };
+            }
+        }
+        return runSetupManifest({ ...options, artifactVerification });
     },
 };
 //# sourceMappingURL=setup-manifest.js.map

package/dist/src/cli/handlers/setup.js

@@ -153,6 +153,13 @@ function secondaryRemotes(remotes, primary, issueTracker, ci) {
         push_on_release: false,
     }));
 }
+function normalizeForcePushPolicy(value, warnings) {
+    if (value === 'main-only-blocked') {
+        warnings.push('delivery.force_push_policy=main-only-blocked is a legacy alias; setup normalized it to own-branch-only.');
+        return 'own-branch-only';
+    }
+    return value;
+}
 function cloneConfig(config) {
     return JSON.parse(JSON.stringify(config));
 }
@@ -191,6 +198,9 @@ function validateSetupConfig(config, remotes, issueProvider) {
     else {
         checkRemote('remotes.issue_tracker', config.remotes?.issue_tracker);
     }
+    if (config.remotes?.issue_provider && !ISSUE_PROVIDERS.includes(config.remotes.issue_provider)) {
+        errors.push('remotes.issue_provider is invalid');
+    }
     checkRemote('remotes.ci', config.remotes?.ci);
     if (!DELIVERY_MODES.includes(config.delivery?.mode))
         errors.push('delivery.mode is invalid');
@@ -222,6 +232,7 @@ export async function buildSetupProjectPlan(options) {
     const primaryRemote = remotes.find(r => r.name === primary);
     const hasLocalIssues = existsSync(projectAiwgPath(options.projectDir, 'issues', 'config.json'));
     const issueProvider = options.issueProvider ?? chooseIssueProvider(primaryRemote, hasLocalIssues);
+    const warnings = [];
     const issueTracker = issueProvider === 'local'
         ? 'local'
         : options.issueTracker ?? base.remotes?.issue_tracker ?? primary;
@@ -229,6 +240,7 @@ export async function buildSetupProjectPlan(options) {
     const remotesConfig = {
         primary,
         issue_tracker: issueTracker,
+        issue_provider: issueProvider,
         ci,
         secondary: base.remotes?.secondary ?? secondaryRemotes(remotes, primary, issueTracker, ci),
     };
@@ -249,9 +261,11 @@ export async function buildSetupProjectPlan(options) {
         require_ci_green: options.requireCiGreen ?? existingDelivery.require_ci_green ?? true,
         auto_close_issues: options.autoCloseIssues ?? existingDelivery.auto_close_issues ?? true,
         issue_comment_on_cycle: options.issueCommentOnCycle ?? existingDelivery.issue_comment_on_cycle ?? true,
-        force_push_policy: options.forcePushPolicy ?? existingDelivery.force_push_policy ?? 'never',
         require_signed_commits: options.requireSignedCommits ?? existingDelivery.require_signed_commits ?? false,
     };
+    delivery.force_push_policy = (options.forcePushPolicy
+        ?? normalizeForcePushPolicy(existingDelivery.force_push_policy, warnings)
+        ?? 'never');
     const committerName = options.committerName ?? existingDelivery.committer?.name ?? gitConfig(options.projectDir, 'user.name');
     const committerEmail = options.committerEmail ?? existingDelivery.committer?.email ?? gitConfig(options.projectDir, 'user.email');
     if (committerName || committerEmail) {
@@ -273,7 +287,6 @@ export async function buildSetupProjectPlan(options) {
     }
     base.remotes = remotesConfig;
     base.delivery = delivery;
-    const warnings = [];
     if (primaryRemote?.provider === 'unknown' && issueProvider !== 'local') {
         warnings.push(`Remote '${primary}' is self-hosted or unknown; provider '${issueProvider}' was selected explicitly/defaulted.`);
     }

package/dist/src/cli/handlers/use.js

@@ -52,10 +52,54 @@ import { generate as generateContextFiles, discoverDeployedArtifacts, } from '..
 import { verifyModelWrapperDeployment } from '../../models/wrapper-deployment.js';
 import { loadGraphIndexFile } from '../../artifacts/index-reader.js';
 import { aggregateUseDeploymentResult, buildDryRunUseResult, renderUseDeploymentResult, verifyProviderDeployment, } from '../services/deployment-verification.js';
+import { finalizeProviderTransformationReceipt, sourceVerificationsFromSignedWebRelease, } from '../../providers/transformation-receipt-integration.js';
+import { loadResourceTrustRootFile, resolveWebRelease, } from '../../resources/web-release.js';
+import { createResourceCredentialProvider } from '../../auth/resource-credentials.js';
 /**
  * Valid framework identifiers
  */
 const VALID_FRAMEWORKS = ['sdlc', 'marketing', 'media-curator', 'research', 'forensics', 'dfir', 'security-engineering', 'ops', 'validation', 'knowledge-base', 'writing', 'general', 'all'];
+function providerReceiptWebReleaseOptions() {
+    const baseUrl = process.env.AIWG_RESOURCE_BASE_URL;
+    const cacheRoot = process.env.AIWG_RESOURCE_CACHE_ROOT;
+    const trustRootFile = process.env.AIWG_RESOURCE_TRUST_ROOT_FILE;
+    const publicKeyPem = trustRootFile === undefined
+        ? undefined
+        : loadResourceTrustRootFile(path.resolve(trustRootFile));
+    return {
+        ...(baseUrl === undefined ? {} : { baseUrl }),
+        ...(cacheRoot === undefined ? {} : { cacheRoot }),
+        ...(publicKeyPem === undefined ? {} : { publicKeyPem }),
+        ...(process.env.AIWG_RESOURCE_ALLOW_INSECURE_LOOPBACK_HTTP === '1'
+            ? { allowInsecureLoopbackHttp: true }
+            : {}),
+    };
+}
+async function signedProviderSourceVerifications(options) {
+    const versionInfo = await getVersionInfo();
+    if (versionInfo.devMode)
+        return undefined;
+    const releaseOptions = providerReceiptWebReleaseOptions();
+    let release;
+    try {
+        release = await resolveWebRelease({ ...releaseOptions, selector: versionInfo.version, offline: true });
+    }
+    catch {
+        const credentialProvider = createResourceCredentialProvider(process.env);
+        const token = await credentialProvider();
+        // Protected production resources require the authenticated release
+        // credential. A configured alternate endpoint may intentionally be public.
+        if (!token && releaseOptions.baseUrl === undefined)
+            return undefined;
+        release = await resolveWebRelease({
+            ...releaseOptions,
+            selector: versionInfo.version,
+            credentialProvider: async () => token,
+        });
+    }
+    const verifications = await sourceVerificationsFromSignedWebRelease(options, release);
+    return Object.keys(verifications).length > 0 ? verifications : undefined;
+}
 /**
  * Framework name to deploy mode mapping.
  * Mode is passed as `--mode <value>` to deploy-agents.mjs, which resolves
@@ -1964,6 +2008,22 @@ export class UseHandler {
                 const effectiveScope = provider === 'openclaw' || provider === 'openhuman'
                     ? 'user'
                     : requestedScope;
+                if (coreResult.exitCode === 0 && !dryRun) {
+                    try {
+                        const receiptOptions = {
+                            projectRoot: projectDir,
+                            frameworkRoot,
+                            provider,
+                            scope: effectiveScope,
+                            requestedBundles: [requestedBundle],
+                        };
+                        const sourceVerifications = await signedProviderSourceVerifications(receiptOptions);
+                        await finalizeProviderTransformationReceipt({ ...receiptOptions, sourceVerifications });
+                    }
+                    catch (error) {
+                        originalConsole.warn(`Provider receipt finalization failed for ${provider}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
                 providerResults.push(await verifyProviderDeployment({
                     projectRoot: projectDir,
                     frameworkRoot,
@@ -1974,6 +2034,10 @@ export class UseHandler {
                     invocationStartedAt: dryRun ? undefined : startedAt,
                     deploymentExitCode: coreResult.exitCode,
                     deploymentMessage: coreResult.message,
+                    // A normal first deployment has no authenticated verifier handoff
+                    // yet, so receipt absence belongs in doctor/status rather than
+                    // degrading an otherwise successful `aiwg use` result.
+                    reportMissingReceipt: false,
                 }));
             }
             result = aggregateUseDeploymentResult({

package/dist/src/cli/services/deployment-verification.js

@@ -4,6 +4,7 @@ import { loadGraphIndexFile } from '../../artifacts/index-reader.js';
 import { readAiwgConfig } from '../../config/aiwg-config.js';
 import { readUserRegistry } from '../../config/user-registry.js';
 import { getProviderDefinition, normalizeProviderDefinitionId, resolveProviderPathValue, } from '../../providers/provider-definitions.js';
+import { diagnoseIntegratedProviderTransformationReceipt } from '../../providers/transformation-receipt-integration.js';
 import { diagnoseWorkspaceContext, providerContextContract, } from '../../smiths/context-pipeline/workspace-context.js';
 import { USER_SCOPE_PATHS } from '../scope-resolver.js';
 const RESTART_NOTICES = {
@@ -120,6 +121,56 @@ function classifyOutcome(findings, restartRequired) {
         return 'degraded';
     return restartRequired ? 'ready-restart-required' : 'ready';
 }
+const RECEIPT_DRIFT_POLICY = {
+    'source-verification-failure': {
+        severity: 'blocking',
+        remediation: 'Restore or reverify the canonical source before regenerating provider outputs.',
+    },
+    'transformation-mismatch': {
+        severity: 'blocking',
+        remediation: 'Review the active provider adapter change, then re-run the same aiwg use command.',
+    },
+    'user-modification': {
+        severity: 'blocking',
+        remediation: 'Back up the changed managed output if needed, then re-run the same aiwg use command.',
+    },
+    'stale-output': {
+        severity: 'blocking',
+        remediation: 'Re-run the same aiwg use command to complete a verified regeneration.',
+    },
+    'missing-receipt': {
+        severity: 'advisory',
+        remediation: 'Re-run the same aiwg use command to establish provider transformation evidence.',
+    },
+};
+async function collectProviderReceiptFindings(options, provider) {
+    try {
+        const diagnosis = await diagnoseIntegratedProviderTransformationReceipt({
+            projectRoot: options.projectRoot,
+            outputRoot: options.outputRoot,
+            frameworkRoot: options.frameworkRoot,
+            provider,
+            scope: options.scope,
+            requestedBundles: options.requestedBundles,
+        });
+        return diagnosis.findings
+            .filter((drift) => options.reportMissingReceipt !== false || drift.kind !== 'missing-receipt')
+            .map((drift, index) => {
+            const policy = RECEIPT_DRIFT_POLICY[drift.kind];
+            return finding(provider, `provider-drift:${drift.kind}:${index}`, policy.severity, drift.message, policy.remediation, {
+                driftClass: drift.kind,
+                receiptPath: diagnosis.receiptPath,
+                checkedOutputs: diagnosis.checkedOutputs,
+                ...(drift.path ? { path: drift.path } : {}),
+                ...(drift.expected ? { expected: drift.expected } : {}),
+                ...(drift.actual ? { actual: drift.actual } : {}),
+            });
+        });
+    }
+    catch (error) {
+        return [finding(provider, 'provider-drift:missing-receipt:0', 'advisory', `Provider transformation evidence could not be evaluated: ${error instanceof Error ? error.message : String(error)}`, RECEIPT_DRIFT_POLICY['missing-receipt'].remediation, { driftClass: 'missing-receipt' })];
+    }
+}
 function indexContainsRequestedBundles(index, requestedBundles) {
     if (requestedBundles.includes('all'))
         return Object.keys(index.entries).length > 0;
@@ -187,17 +238,18 @@ export async function verifyProviderDeployment(options) {
         findings.push(finding(normalized, 'project-root-missing', 'blocking', `Resolved project root does not exist: ${options.projectRoot}`, 'Select an existing project root and run aiwg use again.'));
     }
     if (definition) {
+        const deploymentRoot = options.outputRoot ?? options.projectRoot;
         const artifactPaths = options.scope === 'user'
             ? USER_SCOPE_PATHS[normalized] ?? definition.paths.artifacts
             : definition.paths.artifacts;
         for (const type of ['agents', 'commands', 'skills', 'rules', 'behaviors']) {
-            const resolved = resolveProviderPathValue(artifactPaths[type], options.projectRoot);
+            const resolved = resolveProviderPathValue(artifactPaths[type], deploymentRoot);
             counts[type] = await countEntries(resolved);
         }
-        const resolvedSkillsPath = resolveProviderPathValue(artifactPaths.skills, options.projectRoot);
+        const resolvedSkillsPath = resolveProviderPathValue(artifactPaths.skills, deploymentRoot);
         const kernelPath = options.scope === 'user'
             ? ''
-            : resolveProviderPathValue(definition.paths.kernelSkills, options.projectRoot);
+            : resolveProviderPathValue(definition.paths.kernelSkills, deploymentRoot);
         const kernelCount = await countEntries(kernelPath);
         if (kernelPath && kernelPath !== resolvedSkillsPath)
             counts.skills += kernelCount;
@@ -207,6 +259,7 @@ export async function verifyProviderDeployment(options) {
         }
     }
     findings.push(...await collectRegistryFindings(options, normalized, counts));
+    findings.push(...await collectProviderReceiptFindings(options, normalized));
     const projectConfig = await readAiwgConfig(options.projectRoot);
     const scopedRegistry = options.scope === 'user'
         ? await readUserRegistry()
@@ -300,7 +353,7 @@ export async function verifyProviderDeployment(options) {
     const indexFailed = findings.some((item) => item.id.startsWith('index-'));
     const contextFailed = findings.some((item) => item.id.startsWith('context-') && item.severity === 'blocking');
     const deployFailed = findings.some((item) => item.severity === 'blocking'
-        && (item.id.startsWith('deployment-') || item.id.startsWith('provider-') || item.id.startsWith('registry-')));
+        && (item.id.startsWith('deployment-') || item.id === 'provider-unknown' || item.id === 'provider-artifacts-missing' || item.id.startsWith('registry-')));
     const phases = [
         phase('resolve', 'passed', true, `Resolved ${options.projectRoot}, ${normalized}, ${options.scope} scope.`),
         phase('deploy', deployFailed ? 'failed' : 'passed', true, deployFailed ? 'Deployment invariants failed.' : 'Provider artifacts and installed state verified.', { counts }),
@@ -406,13 +459,18 @@ export function aggregateUseDeploymentResult(options) {
 }
 export async function verifyConfiguredDeployments(projectRoot, filters = {}, frameworkRoot = process.env.AIWG_ROOT || projectRoot) {
     const config = await readAiwgConfig(projectRoot);
+    const userRegistry = filters.scope === 'user' ? await readUserRegistry() : null;
+    const installed = userRegistry?.installed ?? config?.installed ?? {};
+    const registeredProviders = [...new Set(Object.values(installed).flatMap((entry) => Object.keys(entry.deployedTo ?? {})))];
     const providers = filters.provider
         ? [filters.provider]
-        : config?.providers?.length ? config.providers : [];
-    const bundles = filters.bundle ? [filters.bundle] : Object.keys(config?.installed ?? {});
+        : filters.scope === 'user'
+            ? registeredProviders
+            : config?.providers?.length ? config.providers : registeredProviders;
+    const bundles = filters.bundle ? [filters.bundle] : Object.keys(installed);
     const results = [];
     for (const provider of providers) {
-        const providerBundles = bundles.filter((bundle) => Boolean(config?.installed[bundle]?.deployedTo[provider]));
+        const providerBundles = bundles.filter((bundle) => Boolean(installed[bundle]?.deployedTo[provider]));
         if (providerBundles.length === 0)
             continue;
         results.push(await verifyProviderDeployment({

package/dist/src/config/aiwg-config.js

@@ -448,8 +448,8 @@ export async function readIndexConfig(projectDir) {
  *   - any host containing 'gitea' (or matching the typical Gitea path shape) → 'gitea'
  *
  * Returns 'unknown' for self-hosted instances we can't classify by host alone —
- * callers should then prompt the operator or fall back to the configured
- * AIWG provider list.
+ * callers should then prompt the operator or use `remotes.issue_provider`
+ * when the project has declared one.
  *
  * @implements #997
  */
@@ -466,7 +466,7 @@ export function resolveRemoteProvider(remoteUrl) {
     // gitea — identified by hostname token. Self-hosted Gitea instances often
     // don't include 'gitea' in their hostname (e.g. corporate git servers), so
     // 'unknown' is the honest answer there — callers should consult the
-    // configured AIWG provider list rather than guess.
+    // explicit remotes.issue_provider hint rather than guess.
     if (lower.includes('gitea'))
         return 'gitea';
     return 'unknown';
@@ -487,6 +487,7 @@ export function resolveRemotes(remotes) {
     return {
         primary,
         issue_tracker: remotes?.issue_tracker ?? primary,
+        issue_provider: remotes?.issue_provider,
         ci: remotes?.ci ?? primary,
         tracker_actor: remotes?.tracker_actor,
         transport: remotes?.transport,