@h9-foundry/agentforge-cli 0.9.0 → 0.11.0

package/dist/internal/builtin-agents.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { agentManifestSchema, agentOutputSchema, designArtifactSchema, githubActionsEvidenceSchema, implementationArtifactSchema, implementationInventorySchema, incidentArtifactSchema, incidentEvidenceNormalizationSchema, incidentRequestSchema, maintenanceArtifactSchema, maintenanceEvidenceNormalizationSchema, maintenanceRequestSchema, qaArtifactSchema, qaEvidenceNormalizationSchema, qaRequestSchema, releaseApprovalRecommendationSchema, releaseArtifactSchema, releaseEvidenceNormalizationSchema, releaseRequestSchema, securityArtifactSchema, securityEvidenceNormalizationSchema, securityRequestSchema, planningArtifactSchema } from "@h9-foundry/agentforge-schemas";
+import { agentManifestSchema, agentOutputSchema, attestationVerificationEvidenceSchema, buildkiteCiEvidenceExportSchema, ciEvidenceSchema, deploymentGateArtifactSchema, deploymentGateEvidenceNormalizationSchema, deploymentRequestSchema, dependencyIntegrityEvidenceSchema, genericCiEvidenceExportSchema, designArtifactSchema, githubActionsEvidenceSchema, gitlabCiEvidenceExportSchema, jenkinsCiEvidenceExportSchema, implementationArtifactSchema, implementationInventorySchema, incidentArtifactSchema, incidentEvidenceNormalizationSchema, incidentRequestSchema, maintenanceArtifactSchema, maintenanceEvidenceNormalizationSchema, maintenanceRequestSchema, pipelineArtifactSchema, pipelineEvidenceNormalizationSchema, pipelineRequestSchema, qaArtifactSchema, qaEvidenceNormalizationSchema, qaRequestSchema, promotionApprovalArtifactSchema, promotionApprovalEvidenceNormalizationSchema, promotionRequestSchema, releaseApprovalRecommendationSchema, releaseArtifactSchema, releaseCiEvidenceSummarySchema, releaseEvidenceNormalizationSchema, releaseRequestSchema, securityArtifactSchema, securityEvidenceNormalizationSchema, securityRequestSchema, planningArtifactSchema } from "@h9-foundry/agentforge-schemas";
 const contextCollectorAgent = {
     manifest: agentManifestSchema.parse({
         version: 1,
@@ -99,7 +99,14 @@ function resolveWorkspacePackage(root, packageName) {
     }
     return {};
 }
+const dependencyManifestSections = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies"
+];
 const allowedValidationScriptNames = new Set(["test", "lint", "typecheck", "build", "build:packages", "release:verify"]);
+const fallbackValidationPackageManagers = ["pnpm", "npm", "yarn"];
 function normalizeRequestedCommand(command) {
     return command.trim().replace(/\s+/g, " ");
 }
@@ -109,20 +116,29 @@ function buildValidationCommand(packageManager, scriptName, packageName) {
     }
     return `${packageManager} ${scriptName}`;
 }
+function resolveValidationCommandManagers(packageManager, packageName) {
+    if (packageManager !== "unknown") {
+        return [packageManager];
+    }
+    // Generic repos without lockfiles still need deterministic command matching for bounded root scripts.
+    return packageName ? ["pnpm"] : fallbackValidationPackageManagers;
+}
 function collectValidationCommands(repoRoot, packageManager, packageScopes) {
     const discoveredValidationCommands = [];
     const registerScripts = (packageJsonPath, source, packageName) => {
         const scripts = parsePackageScripts(packageJsonPath);
         for (const scriptName of Object.keys(scripts)) {
-            const command = buildValidationCommand(packageManager, scriptName, packageName);
-            discoveredValidationCommands.push({
-                command,
-                source,
-                classification: allowedValidationScriptNames.has(scriptName) ? "approval_required" : "deny",
-                reason: allowedValidationScriptNames.has(scriptName)
-                    ? "Discovered from a bounded repository script; execution would still require approval."
-                    : "Command is not in the bounded allowlist for workflow validation."
-            });
+            for (const commandPackageManager of resolveValidationCommandManagers(packageManager, packageName)) {
+                const command = buildValidationCommand(commandPackageManager, scriptName, packageName);
+                discoveredValidationCommands.push({
+                    command,
+                    source,
+                    classification: allowedValidationScriptNames.has(scriptName) ? "approval_required" : "deny",
+                    reason: allowedValidationScriptNames.has(scriptName)
+                        ? "Discovered from a bounded repository script; execution would still require approval."
+                        : "Command is not in the bounded allowlist for workflow validation."
+                });
+            }
         }
     };
     if (!repoRoot) {
@@ -140,6 +156,183 @@ function collectValidationCommands(repoRoot, packageManager, packageScopes) {
     }
     return discoveredValidationCommands;
 }
+function findDependencyLockfile(repoRoot, packageManager) {
+    if (!repoRoot) {
+        return undefined;
+    }
+    const orderedCandidates = packageManager === "pnpm"
+        ? ["pnpm-lock.yaml", "package-lock.json", "yarn.lock"]
+        : packageManager === "npm"
+            ? ["package-lock.json", "pnpm-lock.yaml", "yarn.lock"]
+            : packageManager === "yarn"
+                ? ["yarn.lock", "pnpm-lock.yaml", "package-lock.json"]
+                : ["pnpm-lock.yaml", "package-lock.json", "yarn.lock"];
+    return orderedCandidates.find((lockfilePath) => existsSync(join(repoRoot, lockfilePath)));
+}
+function readPackageManifestDependencies(repoRoot, manifestPath) {
+    if (!repoRoot) {
+        return undefined;
+    }
+    const absolutePath = join(repoRoot, manifestPath);
+    if (!existsSync(absolutePath)) {
+        return undefined;
+    }
+    const parsed = JSON.parse(readFileSync(absolutePath, "utf8"));
+    if (!isRecord(parsed)) {
+        return undefined;
+    }
+    const packageName = typeof parsed.name === "string" && parsed.name.length > 0 ? parsed.name : manifestPath.replace(/\/package\.json$/, "");
+    const dependencyEntries = [];
+    for (const section of dependencyManifestSections) {
+        const sectionValue = parsed[section];
+        if (!isRecord(sectionValue)) {
+            continue;
+        }
+        for (const [dependencyName, requestedVersion] of Object.entries(sectionValue)) {
+            if (typeof requestedVersion !== "string") {
+                continue;
+            }
+            dependencyEntries.push({
+                manifestPath,
+                packageName,
+                dependencyName,
+                dependencyType: section,
+                requestedVersion
+            });
+        }
+    }
+    return {
+        packageName,
+        dependencyEntries
+    };
+}
+function resolveDependencyManifestPaths(repoRoot, candidatePaths) {
+    if (!repoRoot) {
+        return [];
+    }
+    const normalizedCandidates = candidatePaths.length > 0
+        ? candidatePaths
+        : existsSync(join(repoRoot, "package.json"))
+            ? ["package.json"]
+            : [];
+    const manifestPaths = normalizedCandidates.flatMap((candidatePath) => {
+        const normalizedCandidate = candidatePath.replace(/^\.\//, "");
+        const manifestPath = normalizedCandidate.endsWith("package.json")
+            ? normalizedCandidate
+            : `${normalizedCandidate.replace(/\/$/, "")}/package.json`;
+        return existsSync(join(repoRoot, manifestPath)) ? [manifestPath] : [];
+    });
+    return [...new Set(manifestPaths)];
+}
+function collectDependencyIntegrityEvidence(repoRoot, packageManager, manifestPaths) {
+    if (!repoRoot || manifestPaths.length === 0) {
+        return [];
+    }
+    const manifests = manifestPaths
+        .map((manifestPath) => readPackageManifestDependencies(repoRoot, manifestPath))
+        .filter((manifest) => Boolean(manifest));
+    if (manifests.length === 0) {
+        return [];
+    }
+    const inventoryEntries = manifests.flatMap((manifest) => manifest.dependencyEntries);
+    const packageNames = [...new Set(manifests.map((manifest) => manifest.packageName))];
+    const lockfilePath = findDependencyLockfile(repoRoot, packageManager);
+    const integrityStatus = lockfilePath
+        ? "verified-lockfile"
+        : inventoryEntries.length === 0
+            ? "manifest-only"
+            : "missing-lockfile";
+    return [
+        dependencyIntegrityEvidenceSchema.parse({
+            inventoryFormat: "workspace-inventory",
+            packageManager,
+            integrityStatus,
+            lockfilePath,
+            manifestPaths,
+            packageNames,
+            packageCount: packageNames.length,
+            dependencyEntryCount: inventoryEntries.length,
+            inventoryEntries,
+            provenanceSource: "workspace-scan",
+            provenanceRefs: [...new Set([...manifestPaths, ...(lockfilePath ? [lockfilePath] : [])])]
+        })
+    ];
+}
+function buildDependencyIntegritySignals(evidenceEntries) {
+    return evidenceEntries.flatMap((evidence) => {
+        const signals = [
+            `Dependency inventory covers ${evidence.packageCount} manifest(s) with ${evidence.dependencyEntryCount} declared dependency entr${evidence.dependencyEntryCount === 1 ? "y" : "ies"}.`
+        ];
+        if (evidence.integrityStatus === "verified-lockfile" && evidence.lockfilePath) {
+            signals.push(`Workspace dependency integrity is verified against ${evidence.lockfilePath}.`);
+        }
+        else if (evidence.integrityStatus === "missing-lockfile") {
+            signals.push("Workspace dependency manifests were found without a recognized lockfile.");
+        }
+        else {
+            signals.push("Workspace dependency inventory is manifest-only and does not include lockfile verification.");
+        }
+        return signals;
+    });
+}
+function loadAttestationVerificationEvidence(bundlePath) {
+    if (!existsSync(bundlePath) || !bundlePath.endsWith(".json")) {
+        return undefined;
+    }
+    const parsed = JSON.parse(readFileSync(bundlePath, "utf8"));
+    const candidate = isRecord(parsed) ? { ...parsed, sourcePath: parsed.sourcePath ?? bundlePath } : parsed;
+    const result = attestationVerificationEvidenceSchema.safeParse(candidate);
+    return result.success ? result.data : undefined;
+}
+function normalizeAttestationVerificationEvidence(repoRoot, evidenceSources) {
+    const seen = new Set();
+    const normalized = [];
+    for (const pathValue of evidenceSources) {
+        if (!repoRoot) {
+            continue;
+        }
+        const evidence = loadAttestationVerificationEvidence(join(repoRoot, pathValue));
+        if (!evidence) {
+            continue;
+        }
+        const key = `${evidence.verifier}:${evidence.subject}:${evidence.status}:${evidence.sourcePath ?? pathValue}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        normalized.push(evidence);
+    }
+    return normalized;
+}
+function buildReleaseTrustSummary(evidenceEntries) {
+    if (evidenceEntries.length === 0) {
+        return ["Trusted publishing remains reviewed separately; no attestation verification evidence was supplied."];
+    }
+    const failedCount = evidenceEntries.filter((entry) => entry.status === "failed").length;
+    const verifiedCount = evidenceEntries.filter((entry) => entry.status === "verified").length;
+    const skippedCount = evidenceEntries.filter((entry) => entry.status === "skipped").length;
+    const summary = [];
+    if (verifiedCount > 0) {
+        summary.push(`Verified ${verifiedCount} attestation or provenance evidence export${verifiedCount === 1 ? "" : "s"}.`);
+    }
+    if (failedCount > 0) {
+        summary.push(`Detected ${failedCount} attestation verification failure${failedCount === 1 ? "" : "s"} that require release follow-up.`);
+    }
+    if (skippedCount > 0) {
+        summary.push(`Skipped ${skippedCount} attestation verification evidence export${skippedCount === 1 ? "" : "s"} based on the supplied local evidence.`);
+    }
+    summary.push("Trusted publishing remains reviewed separately from bounded attestation verification.");
+    return summary;
+}
+function resolveReleaseTrustStatus(evidenceEntries) {
+    if (evidenceEntries.some((entry) => entry.status === "failed")) {
+        return "attestation-verification-failed";
+    }
+    if (evidenceEntries.some((entry) => entry.status === "verified")) {
+        return "attestation-verified-trusted-publishing-reviewed-separately";
+    }
+    return "trusted-publishing-reviewed-separately";
+}
 function loadBundleArtifactKinds(bundlePath) {
     if (!existsSync(bundlePath)) {
         return [];
@@ -152,6 +345,121 @@ function loadBundleArtifactKinds(bundlePath) {
         .map((artifact) => (isRecord(artifact) && typeof artifact.artifactKind === "string" ? artifact.artifactKind : undefined))
         .filter((artifactKind) => Boolean(artifactKind));
 }
+function loadBundleLifecycleArtifact(bundlePath, artifactKind) {
+    if (!existsSync(bundlePath)) {
+        return undefined;
+    }
+    const parsed = JSON.parse(readFileSync(bundlePath, "utf8"));
+    if (!isRecord(parsed) || !Array.isArray(parsed.lifecycleArtifacts)) {
+        return undefined;
+    }
+    return parsed.lifecycleArtifacts.find((artifact) => isRecord(artifact) && artifact.artifactKind === artifactKind);
+}
+function evaluateReleaseReportReadiness(bundlePath) {
+    const artifact = loadBundleLifecycleArtifact(bundlePath, "release-report");
+    if (!artifact) {
+        return {
+            ready: false,
+            detail: `Release report bundle is missing a release-report artifact: ${bundlePath}`
+        };
+    }
+    const parsed = releaseArtifactSchema.safeParse(artifact);
+    if (!parsed.success) {
+        return {
+            ready: false,
+            detail: `Release report bundle could not be parsed as a bounded release-report artifact: ${bundlePath}`
+        };
+    }
+    const releaseArtifact = parsed.data;
+    if (releaseArtifact.status !== "complete") {
+        return {
+            ready: false,
+            detail: `Release report ${bundlePath} is ${releaseArtifact.status} and cannot satisfy a deployment gate yet.`
+        };
+    }
+    if (releaseArtifact.payload.readinessStatus !== "ready") {
+        return {
+            ready: false,
+            detail: `Release report ${bundlePath} is ${releaseArtifact.payload.readinessStatus} and cannot satisfy a deployment gate yet.`
+        };
+    }
+    return {
+        ready: true,
+        detail: `Using ${bundlePath} as a ready release-report reference.`
+    };
+}
+function evaluatePipelineReportReadiness(bundlePath) {
+    const artifact = loadBundleLifecycleArtifact(bundlePath, "pipeline-report");
+    if (!artifact) {
+        return {
+            ready: false,
+            detail: `Pipeline report bundle is missing a pipeline-report artifact: ${bundlePath}`
+        };
+    }
+    const parsed = pipelineArtifactSchema.safeParse(artifact);
+    if (!parsed.success) {
+        return {
+            ready: false,
+            detail: `Pipeline report bundle could not be parsed as a bounded pipeline-report artifact: ${bundlePath}`
+        };
+    }
+    const pipelineArtifact = parsed.data;
+    if (pipelineArtifact.status !== "complete") {
+        return {
+            ready: false,
+            detail: `Pipeline report ${bundlePath} is ${pipelineArtifact.status} and cannot satisfy a deployment gate yet.`
+        };
+    }
+    if (pipelineArtifact.payload.reviewStatus !== "ready") {
+        return {
+            ready: false,
+            detail: `Pipeline report ${bundlePath} is ${pipelineArtifact.payload.reviewStatus} and cannot satisfy a deployment gate yet.`
+        };
+    }
+    return {
+        ready: true,
+        detail: `Using ${bundlePath} as a ready pipeline-report reference.`
+    };
+}
+function evaluateDeploymentGateApprovalReadiness(bundlePath, targetEnvironment) {
+    const artifact = loadBundleLifecycleArtifact(bundlePath, "deployment-gate-report");
+    if (!artifact) {
+        return {
+            ready: false,
+            detail: `Deployment gate bundle is missing a deployment-gate-report artifact: ${bundlePath}`
+        };
+    }
+    const parsed = deploymentGateArtifactSchema.safeParse(artifact);
+    if (!parsed.success) {
+        return {
+            ready: false,
+            detail: `Deployment gate bundle could not be parsed as a bounded deployment-gate-report artifact: ${bundlePath}`
+        };
+    }
+    const deploymentGateArtifact = parsed.data;
+    if (deploymentGateArtifact.status !== "complete") {
+        return {
+            ready: false,
+            detail: `Deployment gate report ${bundlePath} is ${deploymentGateArtifact.status} and cannot satisfy promotion approval yet.`
+        };
+    }
+    if (deploymentGateArtifact.payload.gateStatus !== "ready_for_approval") {
+        return {
+            ready: false,
+            detail: `Deployment gate report ${bundlePath} is ${deploymentGateArtifact.payload.gateStatus} and cannot satisfy promotion approval yet.`
+        };
+    }
+    if (targetEnvironment && deploymentGateArtifact.payload.targetEnvironment !== targetEnvironment) {
+        return {
+            ready: false,
+            detail: `Deployment gate report ${bundlePath} targets ${deploymentGateArtifact.payload.targetEnvironment}, not ${targetEnvironment}.`
+        };
+    }
+    return {
+        ready: true,
+        detail: `Using ${bundlePath} as a ready deployment-gate-report reference for ${targetEnvironment ?? deploymentGateArtifact.payload.targetEnvironment}.`
+    };
+}
 function loadBundleArtifactPayloadPaths(bundlePath) {
     if (!existsSync(bundlePath)) {
         return [];
@@ -247,6 +555,292 @@ function normalizeGitHubActionsEvidence(repoRoot, evidenceSources) {
         provenanceRefs
     };
 }
+function mapGitHubActionsEvidenceToCiEvidence(evidence) {
+    return ciEvidenceSchema.parse({
+        platform: "github-actions",
+        providerName: "GitHub Actions",
+        host: "github.com",
+        repository: evidence.repository,
+        pipelineName: evidence.workflowName,
+        pipelineRunId: `${evidence.workflowRunId}`,
+        runAttempt: evidence.runAttempt,
+        event: evidence.event,
+        branch: evidence.headBranch,
+        commitSha: evidence.headSha,
+        status: evidence.status,
+        conclusion: evidence.conclusion,
+        htmlUrl: evidence.htmlUrl,
+        jobs: evidence.jobs,
+        artifacts: [],
+        provenanceSource: "local-export"
+    });
+}
+function loadGitLabCiEvidenceExport(bundlePath) {
+    if (!existsSync(bundlePath) || !bundlePath.endsWith(".json")) {
+        return undefined;
+    }
+    const parsed = JSON.parse(readFileSync(bundlePath, "utf8"));
+    const candidate = isRecord(parsed) ? { ...parsed, sourcePath: parsed.sourcePath ?? bundlePath } : parsed;
+    const result = gitlabCiEvidenceExportSchema.safeParse(candidate);
+    return result.success ? result.data : undefined;
+}
+function loadBuildkiteCiEvidenceExport(bundlePath) {
+    if (!existsSync(bundlePath) || !bundlePath.endsWith(".json")) {
+        return undefined;
+    }
+    const parsed = JSON.parse(readFileSync(bundlePath, "utf8"));
+    const candidate = isRecord(parsed) ? { ...parsed, sourcePath: parsed.sourcePath ?? bundlePath } : parsed;
+    const result = buildkiteCiEvidenceExportSchema.safeParse(candidate);
+    return result.success ? result.data : undefined;
+}
+function loadGenericCiEvidenceExport(bundlePath) {
+    if (!existsSync(bundlePath) || !bundlePath.endsWith(".json")) {
+        return undefined;
+    }
+    const parsed = JSON.parse(readFileSync(bundlePath, "utf8"));
+    const candidate = isRecord(parsed) ? { ...parsed, sourcePath: parsed.sourcePath ?? bundlePath } : parsed;
+    const result = genericCiEvidenceExportSchema.safeParse(candidate);
+    return result.success ? result.data : undefined;
+}
+function loadJenkinsCiEvidenceExport(bundlePath) {
+    if (!existsSync(bundlePath) || !bundlePath.endsWith(".json")) {
+        return undefined;
+    }
+    const parsed = JSON.parse(readFileSync(bundlePath, "utf8"));
+    const candidate = isRecord(parsed) ? { ...parsed, sourcePath: parsed.sourcePath ?? bundlePath } : parsed;
+    const result = jenkinsCiEvidenceExportSchema.safeParse(candidate);
+    return result.success ? result.data : undefined;
+}
+function mapGitLabCiStatus(status) {
+    switch (status) {
+        case "pending":
+            return { status: "queued" };
+        case "running":
+            return { status: "in_progress" };
+        case "success":
+            return { status: "completed", conclusion: "success" };
+        case "failed":
+            return { status: "completed", conclusion: "failure" };
+        case "canceled":
+            return { status: "completed", conclusion: "cancelled" };
+        case "skipped":
+            return { status: "completed", conclusion: "skipped" };
+    }
+}
+function normalizeGitLabCiEvidence(repoRoot, evidenceSources) {
+    return evidenceSources.flatMap((pathValue) => {
+        if (!repoRoot) {
+            return [];
+        }
+        const normalized = loadGitLabCiEvidenceExport(join(repoRoot, pathValue));
+        if (!normalized) {
+            return [];
+        }
+        const pipelineStatus = mapGitLabCiStatus(normalized.status);
+        const jobs = normalized.jobs.map((job) => {
+            const jobStatus = mapGitLabCiStatus(job.status);
+            return {
+                name: job.name,
+                status: jobStatus.status,
+                conclusion: jobStatus.conclusion,
+                htmlUrl: job.webUrl,
+                startedAt: job.startedAt,
+                completedAt: job.completedAt
+            };
+        });
+        const evidence = ciEvidenceSchema.parse({
+            platform: "gitlab-ci",
+            host: normalized.host,
+            repository: normalized.projectPath,
+            pipelineName: normalized.pipelineName,
+            pipelineRunId: `${normalized.pipelineId}`,
+            runAttempt: normalized.runAttempt,
+            event: normalized.event,
+            branch: normalized.branch,
+            commitSha: normalized.commitSha,
+            status: pipelineStatus.status,
+            conclusion: pipelineStatus.conclusion,
+            htmlUrl: normalized.webUrl,
+            jobs,
+            artifacts: [],
+            provenanceSource: "local-export"
+        });
+        return [evidence];
+    });
+}
+function normalizeGenericCiEvidence(repoRoot, evidenceSources) {
+    return evidenceSources.flatMap((pathValue) => {
+        if (!repoRoot) {
+            return [];
+        }
+        const normalized = loadGenericCiEvidenceExport(join(repoRoot, pathValue));
+        if (!normalized) {
+            return [];
+        }
+        const evidence = ciEvidenceSchema.parse({
+            platform: "generic-ci",
+            providerName: normalized.providerName,
+            host: normalized.host,
+            repository: normalized.repository,
+            pipelineName: normalized.pipelineName,
+            pipelineRunId: normalized.pipelineRunId,
+            runAttempt: normalized.runAttempt,
+            event: normalized.event,
+            branch: normalized.branch,
+            commitSha: normalized.commitSha,
+            status: normalized.status,
+            conclusion: normalized.conclusion,
+            htmlUrl: normalized.htmlUrl,
+            jobs: normalized.jobs,
+            artifacts: normalized.artifacts,
+            provenanceSource: "local-export"
+        });
+        return [evidence];
+    });
+}
+function normalizeBuildkiteCiEvidence(repoRoot, evidenceSources) {
+    return evidenceSources.flatMap((pathValue) => {
+        if (!repoRoot) {
+            return [];
+        }
+        const normalized = loadBuildkiteCiEvidenceExport(join(repoRoot, pathValue));
+        if (!normalized) {
+            return [];
+        }
+        const evidence = ciEvidenceSchema.parse({
+            platform: "buildkite",
+            providerName: "Buildkite",
+            host: normalized.host,
+            repository: normalized.repository,
+            pipelineName: normalized.pipelineName,
+            pipelineRunId: normalized.pipelineRunId,
+            runAttempt: normalized.runAttempt,
+            event: normalized.event,
+            branch: normalized.branch,
+            commitSha: normalized.commitSha,
+            status: normalized.status,
+            conclusion: normalized.conclusion,
+            htmlUrl: normalized.htmlUrl,
+            jobs: normalized.jobs,
+            artifacts: normalized.artifacts,
+            provenanceSource: "local-export"
+        });
+        return [evidence];
+    });
+}
+function normalizeJenkinsCiEvidence(repoRoot, evidenceSources) {
+    return evidenceSources.flatMap((pathValue) => {
+        if (!repoRoot) {
+            return [];
+        }
+        const normalized = loadJenkinsCiEvidenceExport(join(repoRoot, pathValue));
+        if (!normalized) {
+            return [];
+        }
+        const evidence = ciEvidenceSchema.parse({
+            platform: "jenkins-ci",
+            providerName: "Jenkins",
+            host: normalized.host,
+            repository: normalized.repository,
+            pipelineName: normalized.pipelineName,
+            pipelineRunId: normalized.pipelineRunId,
+            runAttempt: normalized.runAttempt,
+            event: normalized.event,
+            branch: normalized.branch,
+            commitSha: normalized.commitSha,
+            status: normalized.status,
+            conclusion: normalized.conclusion,
+            htmlUrl: normalized.htmlUrl,
+            jobs: normalized.jobs,
+            artifacts: normalized.artifacts,
+            provenanceSource: "local-export"
+        });
+        return [evidence];
+    });
+}
+function normalizeImportedCiEvidence(repoRoot, evidenceSources) {
+    const seen = new Set();
+    const normalized = [];
+    for (const pathValue of evidenceSources) {
+        if (!repoRoot) {
+            continue;
+        }
+        const absolutePath = join(repoRoot, pathValue);
+        if (!existsSync(absolutePath) || !absolutePath.endsWith(".json")) {
+            continue;
+        }
+        const evidence = (() => {
+            const githubActions = loadGitHubActionsEvidence(absolutePath);
+            if (githubActions) {
+                return mapGitHubActionsEvidenceToCiEvidence(githubActions);
+            }
+            const gitlab = loadGitLabCiEvidenceExport(absolutePath);
+            if (gitlab) {
+                return normalizeGitLabCiEvidence(repoRoot, [pathValue])[0];
+            }
+            const buildkite = loadBuildkiteCiEvidenceExport(absolutePath);
+            if (buildkite) {
+                return normalizeBuildkiteCiEvidence(repoRoot, [pathValue])[0];
+            }
+            const jenkins = loadJenkinsCiEvidenceExport(absolutePath);
+            if (jenkins) {
+                return normalizeJenkinsCiEvidence(repoRoot, [pathValue])[0];
+            }
+            const generic = loadGenericCiEvidenceExport(absolutePath);
+            if (generic) {
+                return normalizeGenericCiEvidence(repoRoot, [pathValue])[0];
+            }
+            return undefined;
+        })();
+        if (!evidence) {
+            continue;
+        }
+        const key = `${evidence.platform}:${evidence.host}:${evidence.pipelineRunId}:${evidence.pipelineName}:${evidence.repository}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        normalized.push(evidence);
+    }
+    return normalized;
+}
+function summarizeCiEvidenceFailures(evidence) {
+    const failedJobs = evidence.jobs
+        .filter((job) => job.status === "completed" && isFailingGitHubActionsConclusion(job.conclusion))
+        .map((job) => `${evidence.pipelineName} / ${job.name}`);
+    const runLevelFailure = failedJobs.length === 0 &&
+        evidence.status === "completed" &&
+        isFailingGitHubActionsConclusion(evidence.conclusion)
+        ? [`${evidence.pipelineName} / pipeline-run`]
+        : [];
+    return [...failedJobs, ...runLevelFailure];
+}
+function formatCiEvidenceStatus(evidence) {
+    if (evidence.status === "completed" && evidence.conclusion) {
+        return evidence.conclusion;
+    }
+    return evidence.status;
+}
+function summarizeCiEvidenceForRelease(evidence) {
+    const provider = evidence.providerName ?? evidence.pipelineName;
+    const displayLabel = `${provider} (${evidence.platform}) pipeline \`${evidence.pipelineName}\` run \`${evidence.pipelineRunId}\``;
+    return releaseCiEvidenceSummarySchema.parse({
+        provider,
+        platform: evidence.platform,
+        host: evidence.host,
+        repository: evidence.repository,
+        pipelineName: evidence.pipelineName,
+        pipelineRunId: evidence.pipelineRunId,
+        status: evidence.status,
+        conclusion: evidence.conclusion,
+        branch: evidence.branch,
+        commitSha: evidence.commitSha,
+        failingChecks: summarizeCiEvidenceFailures(evidence),
+        provenanceSource: evidence.provenanceSource,
+        displayLabel,
+        statusSummary: `${displayLabel} completed from ${evidence.provenanceSource} evidence with ${formatCiEvidenceStatus(evidence)}.`
+    });
+}
 function derivePackageScope(pathValue) {
     const segments = pathValue.split("/").filter(Boolean);
     if (segments.length < 2) {
@@ -268,7 +862,7 @@ function getWorkflowInput(stateSlice, key) {
     }
     return stateSlice.workflowInputs[key];
 }
-function buildLifecycleArtifactEnvelopeBase(state, displayName, summary, inputRefs, issueRefs = [], githubRefs = []) {
+function buildLifecycleArtifactEnvelopeBase(state, displayName, summary, inputRefs, issueRefs = [], scmRefs = [], githubRefs = []) {
     return {
         schemaVersion: state.version,
         workflow: {
@@ -280,6 +874,7 @@ function buildLifecycleArtifactEnvelopeBase(state, displayName, summary, inputRe
             runId: state.runId,
             inputRefs: [...inputRefs],
             issueRefs: [...issueRefs],
+            scmRefs: [...scmRefs],
             githubRefs: [...githubRefs]
         },
         status: "complete",
@@ -308,7 +903,7 @@ function buildLifecycleArtifactEnvelopeBase(state, displayName, summary, inputRe
         summary
     };
 }
-function buildArtifactEnvelopeBase(state, summary, inputRefs, issueRefs, githubRefs = []) {
+function buildArtifactEnvelopeBase(state, summary, inputRefs, issueRefs, scmRefs = [], githubRefs = []) {
     return {
         schemaVersion: state.version,
         workflow: {
@@ -319,6 +914,7 @@ function buildArtifactEnvelopeBase(state, summary, inputRefs, issueRefs, githubR
             runId: state.runId,
             inputRefs: [...inputRefs],
             issueRefs: [...issueRefs],
+            scmRefs: [...scmRefs],
             githubRefs: [...githubRefs]
         },
         status: "complete",
@@ -445,6 +1041,7 @@ const planningAnalystAgent = {
     outputSchema: agentOutputSchema,
     async execute({ state, stateSlice }) {
         const planningRequest = getWorkflowInput(stateSlice, "planningRequest");
+        const planningScmRefs = getWorkflowInput(stateSlice, "planningScmRefs") ?? [];
         const planningGithubRefs = getWorkflowInput(stateSlice, "planningGithubRefs") ?? [];
         const requestFile = getWorkflowInput(stateSlice, "requestFile");
         if (!planningRequest) {
@@ -469,7 +1066,7 @@ const planningAnalystAgent = {
         ];
         const summary = `Planning brief scoped ${objectives.length} objective(s) for ${state.repo.name}.`;
         const planningBrief = planningArtifactSchema.parse({
-            ...buildArtifactEnvelopeBase(state, summary, [requestFile ?? ".agentops/requests/planning.yaml"], planningRequest.issueRefs, planningGithubRefs),
+            ...buildArtifactEnvelopeBase(state, summary, [requestFile ?? ".agentops/requests/planning.yaml"], planningRequest.issueRefs, planningScmRefs, planningGithubRefs),
             artifactKind: "planning-brief",
             lifecycleDomain: "plan",
             workflow: {
@@ -1064,6 +1661,7 @@ const maintenanceIntakeAgent = {
         const maintenanceRequest = getWorkflowInput(stateSlice, "maintenanceRequest");
         const requestFile = getWorkflowInput(stateSlice, "requestFile");
         const maintenanceIssueRefs = getWorkflowInput(stateSlice, "maintenanceIssueRefs") ?? [];
+        const maintenanceScmRefs = getWorkflowInput(stateSlice, "maintenanceScmRefs") ?? [];
         const maintenanceGithubRefs = getWorkflowInput(stateSlice, "maintenanceGithubRefs") ?? [];
         if (!maintenanceRequest) {
             throw new Error("maintenance-triage requires a validated maintenance request before runtime execution.");
@@ -1084,6 +1682,7 @@ const maintenanceIntakeAgent = {
                     issueRefs: [...new Set(maintenanceRequest.issueRefs)]
                 }),
                 maintenanceIssueRefs,
+                maintenanceScmRefs,
                 maintenanceGithubRefs,
                 evidenceSourceCount: maintenanceRequest.dependencyAlertRefs.length +
                     maintenanceRequest.docsTaskRefs.length +
@@ -1256,6 +1855,7 @@ const maintenanceAnalystAgent = {
     async execute({ state, stateSlice }) {
         const maintenanceRequest = getWorkflowInput(stateSlice, "maintenanceRequest");
         const maintenanceIssueRefs = getWorkflowInput(stateSlice, "maintenanceIssueRefs") ?? [];
+        const maintenanceScmRefs = getWorkflowInput(stateSlice, "maintenanceScmRefs") ?? [];
         const maintenanceGithubRefs = getWorkflowInput(stateSlice, "maintenanceGithubRefs") ?? [];
         const requestFile = getWorkflowInput(stateSlice, "requestFile");
         if (!maintenanceRequest) {
@@ -1320,7 +1920,7 @@ const maintenanceAnalystAgent = {
         ];
         const summary = `Maintenance report prepared for ${maintenanceRequest.maintenanceGoal}.`;
         const maintenanceReport = maintenanceArtifactSchema.parse({
-            ...buildLifecycleArtifactEnvelopeBase(state, "Maintenance Triage", summary, [requestFile ?? ".agentops/requests/maintenance.yaml", ...evidenceSources], maintenanceIssueRefs, maintenanceGithubRefs),
+            ...buildLifecycleArtifactEnvelopeBase(state, "Maintenance Triage", summary, [requestFile ?? ".agentops/requests/maintenance.yaml", ...evidenceSources], maintenanceIssueRefs, maintenanceScmRefs, maintenanceGithubRefs),
             artifactKind: "maintenance-report",
             lifecycleDomain: "maintain",
             payload: {
@@ -1415,6 +2015,7 @@ const incidentAnalystAgent = {
         const incidentRequest = getWorkflowInput(stateSlice, "incidentRequest");
         const requestFile = getWorkflowInput(stateSlice, "requestFile");
         const incidentIssueRefs = getWorkflowInput(stateSlice, "incidentIssueRefs") ?? [];
+        const incidentScmRefs = getWorkflowInput(stateSlice, "incidentScmRefs") ?? [];
         const incidentGithubRefs = getWorkflowInput(stateSlice, "incidentGithubRefs") ?? [];
         if (!incidentRequest) {
             throw new Error("incident-handoff requires validated incident inputs before incident analysis.");
@@ -1457,7 +2058,7 @@ const incidentAnalystAgent = {
         ];
         const summary = `Incident brief prepared for ${incidentRequest.incidentSummary}.`;
         const incidentBrief = incidentArtifactSchema.parse({
-            ...buildLifecycleArtifactEnvelopeBase(state, "Incident Handoff", summary, [requestFile ?? ".agentops/requests/incident.yaml", ...evidenceSources], incidentIssueRefs, incidentGithubRefs),
+            ...buildLifecycleArtifactEnvelopeBase(state, "Incident Handoff", summary, [requestFile ?? ".agentops/requests/incident.yaml", ...evidenceSources], incidentIssueRefs, incidentScmRefs, incidentGithubRefs),
             artifactKind: "incident-brief",
             lifecycleDomain: "operate",
             redaction: {
@@ -1551,6 +2152,7 @@ const releaseIntakeAgent = {
     async execute({ stateSlice }) {
         const releaseRequest = getWorkflowInput(stateSlice, "releaseRequest");
         const releaseIssueRefs = getWorkflowInput(stateSlice, "releaseIssueRefs") ?? [];
+        const releaseScmRefs = getWorkflowInput(stateSlice, "releaseScmRefs") ?? [];
         const releaseGithubRefs = getWorkflowInput(stateSlice, "releaseGithubRefs") ?? [];
         const requestFile = getWorkflowInput(stateSlice, "requestFile");
         if (!releaseRequest) {
@@ -1566,6 +2168,7 @@ const releaseIntakeAgent = {
             metadata: {
                 ...releaseRequestSchema.parse(releaseRequest),
                 releaseIssueRefs,
+                releaseScmRefs,
                 releaseGithubRefs,
                 evidenceSourceCount: releaseRequest.qaReportRefs.length + releaseRequest.securityReportRefs.length + releaseRequest.evidenceSources.length
             }
@@ -1625,6 +2228,10 @@ const releaseEvidenceNormalizationAgent = {
             ? asStringArray(intakeMetadata.evidenceSources)
             : releaseRequest.evidenceSources;
         const normalizedEvidenceSources = [...new Set([...qaReportRefs, ...securityReportRefs, ...evidenceSources])];
+        const ciEvidence = normalizeImportedCiEvidence(repoRoot, normalizedEvidenceSources);
+        const ciEvidenceSummary = ciEvidence.map((entry) => summarizeCiEvidenceForRelease(entry));
+        const attestationVerificationEvidence = normalizeAttestationVerificationEvidence(repoRoot, normalizedEvidenceSources);
+        const trustSummary = buildReleaseTrustSummary(attestationVerificationEvidence);
         const missingEvidenceSources = normalizedEvidenceSources.filter((pathValue) => repoRoot && !existsSync(join(repoRoot, pathValue)));
         if (missingEvidenceSources.length > 0) {
             throw new Error(`Release evidence source not found: ${missingEvidenceSources[0]}`);
@@ -1643,6 +2250,17 @@ const releaseEvidenceNormalizationAgent = {
                 manifestPath: resolved.manifestPath
             };
         });
+        const dependencyManifestPaths = resolveDependencyManifestPaths(repoRoot, [
+            "package.json",
+            ...versionResolutions
+                .map((entry) => entry.manifestPath)
+                .filter((value) => Boolean(value))
+                .map((manifestPath) => manifestPath.replace(`${repoRoot ?? ""}/`, ""))
+        ]);
+        const dependencyIntegrityEvidence = collectDependencyIntegrityEvidence(repoRoot, stateSlice.repo?.packageManager || "unknown", dependencyManifestPaths);
+        const dependencyIntegritySignals = buildDependencyIntegritySignals(dependencyIntegrityEvidence);
+        const hasMissingDependencyIntegrity = dependencyIntegrityEvidence.some((entry) => entry.integrityStatus === "missing-lockfile");
+        const hasFailedAttestationVerification = attestationVerificationEvidence.some((entry) => entry.status === "failed");
         const missingPackages = versionResolutions.filter((entry) => entry.status === "package-missing").map((entry) => entry.name);
         const versionCheckStatus = missingPackages.length === 0 ? "passed" : "failed";
         const baseReadinessStatus = qaReportRefs.length > 0 && securityReportRefs.length > 0
@@ -1650,7 +2268,13 @@ const releaseEvidenceNormalizationAgent = {
             : qaReportRefs.length > 0 || securityReportRefs.length > 0
                 ? "partial"
                 : "blocked";
-        const readinessStatus = missingPackages.length > 0 ? "blocked" : baseReadinessStatus;
+        const readinessStatus = missingPackages.length > 0
+            ? "blocked"
+            : hasFailedAttestationVerification
+                ? "blocked"
+                : hasMissingDependencyIntegrity && baseReadinessStatus === "ready"
+                    ? "partial"
+                    : baseReadinessStatus;
         const localReadinessChecks = [
             {
                 name: "qa-report-refs",
@@ -1673,6 +2297,32 @@ const releaseEvidenceNormalizationAgent = {
                     ? `Using ${evidenceSources.length} bounded local release evidence source(s).`
                     : "No additional local release evidence sources were supplied."
             },
+            {
+                name: "imported-ci-evidence",
+                status: ciEvidence.length > 0 ? "passed" : "skipped",
+                detail: ciEvidence.length > 0
+                    ? `Using ${ciEvidence.length} imported CI evidence export(s) across ${[...new Set(ciEvidence.map((entry) => entry.pipelineName))].length} pipeline(s).`
+                    : "No imported CI evidence exports were supplied."
+            },
+            {
+                name: "dependency-integrity",
+                status: dependencyIntegrityEvidence.length === 0
+                    ? "skipped"
+                    : hasMissingDependencyIntegrity
+                        ? "failed"
+                        : "passed",
+                detail: dependencyIntegritySignals[0] ??
+                    "No dependency manifests were available for bounded integrity verification."
+            },
+            {
+                name: "attestation-verification",
+                status: attestationVerificationEvidence.length === 0
+                    ? "skipped"
+                    : hasFailedAttestationVerification
+                        ? "failed"
+                        : "passed",
+                detail: trustSummary[0]
+            },
             {
                 name: "workspace-version-targets",
                 status: versionCheckStatus,
@@ -1706,6 +2356,8 @@ const releaseEvidenceNormalizationAgent = {
         ];
         const provenanceRefs = [
             ...normalizedEvidenceSources,
+            ...dependencyIntegrityEvidence.flatMap((entry) => entry.provenanceRefs),
+            ...attestationVerificationEvidence.flatMap((entry) => entry.provenanceRefs),
             ...versionResolutions
                 .map((entry) => entry.manifestPath)
                 .filter((value) => Boolean(value))
@@ -1715,6 +2367,10 @@ const releaseEvidenceNormalizationAgent = {
             securityReportRefs,
             normalizedEvidenceSources,
             missingEvidenceSources: [],
+            ciEvidence,
+            ciEvidenceSummary,
+            dependencyIntegrityEvidence,
+            attestationVerificationEvidence,
             versionResolutions: versionResolutions.map((entry) => ({
                 name: entry.name,
                 targetVersion: entry.targetVersion,
@@ -1724,6 +2380,7 @@ const releaseEvidenceNormalizationAgent = {
             localReadinessChecks,
             readinessStatus,
             approvalRecommendations,
+            trustSummary,
             provenanceRefs: [...new Set(provenanceRefs)]
         });
         return agentOutputSchema.parse({
@@ -1776,6 +2433,7 @@ const releaseAnalystAgent = {
     async execute({ state, stateSlice }) {
         const releaseRequest = getWorkflowInput(stateSlice, "releaseRequest");
         const releaseIssueRefs = getWorkflowInput(stateSlice, "releaseIssueRefs") ?? [];
+        const releaseScmRefs = getWorkflowInput(stateSlice, "releaseScmRefs") ?? [];
         const releaseGithubRefs = getWorkflowInput(stateSlice, "releaseGithubRefs") ?? [];
         const requestFile = getWorkflowInput(stateSlice, "requestFile");
         if (!releaseRequest) {
@@ -1801,6 +2459,13 @@ const releaseAnalystAgent = {
                 : releaseRequest.evidenceSources;
         const constraints = asStringArray(intakeMetadata.constraints);
         const allEvidenceRefs = [...new Set([...qaReportRefs, ...securityReportRefs, ...evidenceSources])];
+        const importedCiEvidence = normalizedEvidence?.ciEvidence ?? [];
+        const ciEvidenceSummary = normalizedEvidence?.ciEvidenceSummary ?? importedCiEvidence.map((entry) => summarizeCiEvidenceForRelease(entry));
+        const dependencyIntegrityEvidence = normalizedEvidence?.dependencyIntegrityEvidence ?? [];
+        const dependencyIntegritySignals = buildDependencyIntegritySignals(dependencyIntegrityEvidence);
+        const attestationVerificationEvidence = normalizedEvidence?.attestationVerificationEvidence ?? [];
+        const trustSummary = normalizedEvidence?.trustSummary ?? buildReleaseTrustSummary(attestationVerificationEvidence);
+        const importedCiFailures = [...new Set(ciEvidenceSummary.flatMap((entry) => entry.failingChecks))];
         const versionResolutions = normalizedEvidence?.versionResolutions ?? [];
         const verificationChecks = normalizedEvidence?.localReadinessChecks ?? [
             {
@@ -1823,6 +2488,13 @@ const releaseAnalystAgent = {
                 detail: evidenceSources.length > 0
                     ? `Using ${evidenceSources.length} bounded local release evidence source(s).`
                     : "No additional local release evidence sources were supplied."
+            },
+            {
+                name: "imported-ci-evidence",
+                status: importedCiEvidence.length > 0 ? "passed" : "skipped",
+                detail: importedCiEvidence.length > 0
+                    ? `Using ${importedCiEvidence.length} imported CI evidence export(s) across ${ciEvidenceSummary.map((entry) => entry.provider).join(", ")}.`
+                    : "No imported CI evidence exports were supplied."
             }
         ];
         const readinessStatus = normalizedEvidence?.readinessStatus ??
@@ -1845,7 +2517,10 @@ const releaseAnalystAgent = {
             ...(versionResolutions.length > 0
                 ? [`Resolved ${versionResolutions.length} workspace version target(s) before any publish or promotion step.`]
                 : []),
+            ...dependencyIntegritySignals.map((signal) => `${signal} Review dependency integrity before any publish or promotion step.`),
+            ...trustSummary.map((line) => `${line} Keep publish execution separate from verification.`),
             "Review the bounded QA and security evidence before invoking any publish or promotion step.",
+            ...ciEvidenceSummary.map((entry) => `Review ${entry.displayLabel} (${formatCiEvidenceStatus(entry)}) before any publish or promotion step.`),
             "Run `agentforge release check --json` and `agentforge release verify --json` before any release cut.",
             ...approvalRecommendations.map((recommendation) => `${recommendation.action}: ${recommendation.classification.replaceAll("_", " ")} (${recommendation.reason})`),
             "Keep trusted publishing and tag or publish actions outside this default read-only workflow path."
@@ -1856,10 +2531,11 @@ const releaseAnalystAgent = {
         ];
         const externalDependencies = [
             ...(qaReportRefs.length > 0 ? ["Validated QA report inputs remain available for reviewer inspection."] : []),
-            ...(securityReportRefs.length > 0 ? ["Validated security report inputs remain available for reviewer inspection."] : [])
+            ...(securityReportRefs.length > 0 ? ["Validated security report inputs remain available for reviewer inspection."] : []),
+            ...ciEvidenceSummary.map((entry) => `${entry.displayLabel} remains available for reviewer inspection.`)
         ];
         const releaseReport = releaseArtifactSchema.parse({
-            ...buildLifecycleArtifactEnvelopeBase(state, "Release Readiness", summary, [requestFile ?? ".agentops/requests/release.yaml", ...allEvidenceRefs], releaseIssueRefs, releaseGithubRefs),
+            ...buildLifecycleArtifactEnvelopeBase(state, "Release Readiness", summary, [requestFile ?? ".agentops/requests/release.yaml", ...allEvidenceRefs], releaseIssueRefs, releaseScmRefs, releaseGithubRefs),
             artifactKind: "release-report",
             lifecycleDomain: "release",
             payload: {
@@ -1868,9 +2544,12 @@ const releaseAnalystAgent = {
                 readinessStatus,
                 verificationChecks: verificationChecks.map((check) => ({ ...check })),
                 versionResolutions,
+                ciEvidenceSummary,
+                dependencyIntegritySignals,
+                trustSummary,
                 approvalRecommendations: approvalRecommendations.map((recommendation) => releaseApprovalRecommendationSchema.parse(recommendation)),
                 publishingPlan,
-                trustStatus: "trusted-publishing-reviewed-separately",
+                trustStatus: resolveReleaseTrustStatus(attestationVerificationEvidence),
                 publishedPackages: [],
                 tagRefs: [],
                 provenanceRefs: allEvidenceRefs,
@@ -1892,6 +2571,10 @@ const releaseAnalystAgent = {
                     qaReportRefs,
                     securityReportRefs,
                     evidenceSources,
+                    ciEvidence: importedCiEvidence,
+                    ciEvidenceSummary,
+                    dependencyIntegrityEvidence,
+                    attestationVerificationEvidence,
                     constraints,
                     normalizedEvidence: normalizedEvidence ?? null
                 },
@@ -1899,18 +2582,20 @@ const releaseAnalystAgent = {
                     readinessStatus,
                     approvalRecommendations,
                     publishingPlan,
-                    rollbackNotes
+                    rollbackNotes,
+                    trustSummary,
+                    importedCiFailures
                 }
             }
         });
     }
 };
-const securityEvidenceNormalizationAgent = {
+const pipelineIntakeAgent = {
     manifest: agentManifestSchema.parse({
         version: 1,
-        name: "security-evidence-normalizer",
-        displayName: "Security Evidence Normalizer",
-        category: "security",
+        name: "pipeline-intake",
+        displayName: "Pipeline Intake",
+        category: "release",
         runtime: {
             minVersion: "0.1.0",
             kind: "deterministic"
@@ -1919,17 +2604,17 @@ const securityEvidenceNormalizationAgent = {
             model: false,
             network: false,
             tools: [],
-            readPaths: [".agentops/requests/**", ".agentops/runs/**", "**/*.json", "**/*.md", "**/package.json"],
+            readPaths: [".agentops/requests/**", ".agentops/runs/**"],
             writePaths: []
         },
-        inputs: ["workflowInputs", "repo", "agentResults"],
+        inputs: ["workflowInputs", "repo"],
         outputs: ["summary", "metadata"],
         contextPolicy: {
-            sections: ["workflowInputs", "repo", "agentResults"],
+            sections: ["workflowInputs", "repo", "context"],
             minimalContext: true
         },
         catalog: {
-            domain: "security",
+            domain: "release",
             supportLevel: "internal",
             maturity: "mvp",
             trustScope: "official-core-only"
@@ -1942,48 +2627,1052 @@ const securityEvidenceNormalizationAgent = {
     }),
     outputSchema: agentOutputSchema,
     async execute({ stateSlice }) {
-        const securityRequest = getWorkflowInput(stateSlice, "securityRequest");
-        if (!securityRequest) {
-            throw new Error("security-review requires validated security request inputs before evidence normalization.");
-        }
-        const repoRoot = stateSlice.repo?.root;
-        const intakeMetadata = isRecord(stateSlice.agentResults?.intake?.metadata) ? stateSlice.agentResults.intake.metadata : {};
-        const targetType = typeof intakeMetadata.targetType === "string" && intakeMetadata.targetType === "artifact-bundle"
-            ? "artifact-bundle"
-            : "local-reference";
-        const targetPath = repoRoot ? join(repoRoot, securityRequest.targetRef) : securityRequest.targetRef;
-        if (repoRoot && !existsSync(targetPath)) {
-            throw new Error(`Security target reference not found: ${securityRequest.targetRef}`);
-        }
-        const referencedArtifactKinds = targetType === "artifact-bundle" ? loadBundleArtifactKinds(targetPath) : [];
-        const normalizedEvidenceSources = [...new Set([securityRequest.targetRef, ...securityRequest.evidenceSources])];
-        const missingEvidenceSources = normalizedEvidenceSources.filter((pathValue) => repoRoot && !existsSync(join(repoRoot, pathValue)));
-        if (missingEvidenceSources.length > 0) {
-            throw new Error(`Security evidence source not found: ${missingEvidenceSources[0]}`);
+        const pipelineRequest = getWorkflowInput(stateSlice, "pipelineRequest");
+        const pipelineIssueRefs = getWorkflowInput(stateSlice, "pipelineIssueRefs") ?? [];
+        const pipelineScmRefs = getWorkflowInput(stateSlice, "pipelineScmRefs") ?? [];
+        const pipelineGithubRefs = getWorkflowInput(stateSlice, "pipelineGithubRefs") ?? [];
+        const requestFile = getWorkflowInput(stateSlice, "requestFile");
+        if (!pipelineRequest) {
+            throw new Error("pipeline-evidence-review requires a validated pipeline request before runtime execution.");
         }
-        const normalizedFocusAreas = securityRequest.focusAreas.length > 0 ? [...new Set(securityRequest.focusAreas)] : ["general-review"];
-        const affectedPackages = targetType === "artifact-bundle"
-            ? [...new Set(loadBundleArtifactPayloadPaths(targetPath).map(derivePackageScope).filter((value) => Boolean(value)))]
-            : [];
-        const securitySignals = [
-            ...(referencedArtifactKinds.length > 0 ? [`Referenced artifact kinds: ${referencedArtifactKinds.join(", ")}`] : []),
-            ...(affectedPackages.length > 0 ? [`Affected packages inferred from bounded artifact payloads: ${affectedPackages.join(", ")}`] : []),
-            ...(normalizedFocusAreas.length > 0 ? [`Requested focus areas: ${normalizedFocusAreas.join(", ")}`] : []),
-            "Security evidence collection remains local, read-only, and bounded to validated references."
-        ];
-        const provenanceRefs = [
-            securityRequest.targetRef,
-            ...securityRequest.evidenceSources,
-            ...referencedArtifactKinds.map((artifactKind) => `${securityRequest.targetRef}#${artifactKind}`)
-        ];
-        const normalization = securityEvidenceNormalizationSchema.parse({
-            targetRef: securityRequest.targetRef,
+        return agentOutputSchema.parse({
+            summary: `Loaded pipeline request from ${requestFile ?? ".agentops/requests/pipeline.yaml"} for ${pipelineRequest.pipelineScope}.`,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [],
+            requestedTools: [],
+            blockedActionFlags: [],
+            metadata: {
+                ...pipelineRequestSchema.parse(pipelineRequest),
+                pipelineIssueRefs,
+                pipelineScmRefs,
+                pipelineGithubRefs,
+                evidenceSourceCount: pipelineRequest.evidenceSources.length +
+                    pipelineRequest.qaReportRefs.length +
+                    pipelineRequest.securityReportRefs.length +
+                    pipelineRequest.releaseReportRefs.length
+            }
+        });
+    }
+};
+const pipelineEvidenceNormalizationAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "pipeline-evidence-normalizer",
+        displayName: "Pipeline Evidence Normalizer",
+        category: "release",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "deterministic"
+        },
+        permissions: {
+            model: false,
+            network: false,
+            tools: [],
+            readPaths: [".agentops/requests/**", ".agentops/runs/**", "**/*.json", "**/*.md"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo", "agentResults"],
+        outputs: ["summary", "metadata"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "agentResults"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "release",
+            supportLevel: "internal",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ stateSlice }) {
+        const pipelineRequest = getWorkflowInput(stateSlice, "pipelineRequest");
+        if (!pipelineRequest) {
+            throw new Error("pipeline-evidence-review requires validated pipeline request inputs before evidence normalization.");
+        }
+        const repoRoot = stateSlice.repo?.root;
+        const intakeMetadata = isRecord(stateSlice.agentResults?.intake?.metadata) ? stateSlice.agentResults.intake.metadata : {};
+        const qaReportRefs = asStringArray(intakeMetadata.qaReportRefs).length > 0
+            ? asStringArray(intakeMetadata.qaReportRefs)
+            : pipelineRequest.qaReportRefs;
+        const securityReportRefs = asStringArray(intakeMetadata.securityReportRefs).length > 0
+            ? asStringArray(intakeMetadata.securityReportRefs)
+            : pipelineRequest.securityReportRefs;
+        const releaseReportRefs = asStringArray(intakeMetadata.releaseReportRefs).length > 0
+            ? asStringArray(intakeMetadata.releaseReportRefs)
+            : pipelineRequest.releaseReportRefs;
+        const evidenceSources = asStringArray(intakeMetadata.evidenceSources).length > 0
+            ? asStringArray(intakeMetadata.evidenceSources)
+            : pipelineRequest.evidenceSources;
+        const normalizedEvidenceSources = [...new Set([...qaReportRefs, ...securityReportRefs, ...releaseReportRefs, ...evidenceSources])];
+        const missingEvidenceSources = normalizedEvidenceSources.filter((pathValue) => repoRoot && !existsSync(join(repoRoot, pathValue)));
+        if (missingEvidenceSources.length > 0) {
+            throw new Error(`Pipeline evidence source not found: ${missingEvidenceSources[0]}`);
+        }
+        const referencedArtifactKinds = [
+            ...new Set([...qaReportRefs, ...securityReportRefs, ...releaseReportRefs].flatMap((bundleRef) => repoRoot ? loadBundleArtifactKinds(join(repoRoot, bundleRef)) : []))
+        ];
+        const ciEvidence = normalizeImportedCiEvidence(repoRoot, normalizedEvidenceSources);
+        const ciEvidenceSummary = ciEvidence.map((entry) => summarizeCiEvidenceForRelease(entry));
+        const failingChecks = ciEvidenceSummary.flatMap((entry) => entry.failingChecks);
+        const verificationChecks = [
+            {
+                name: "referenced-artifacts",
+                status: qaReportRefs.length + securityReportRefs.length + releaseReportRefs.length > 0 ? "passed" : "skipped",
+                detail: qaReportRefs.length + securityReportRefs.length + releaseReportRefs.length > 0
+                    ? `Validated ${qaReportRefs.length + securityReportRefs.length + releaseReportRefs.length} referenced artifact bundle(s).`
+                    : "No upstream lifecycle artifact references were supplied."
+            },
+            {
+                name: "imported-ci-evidence",
+                status: ciEvidence.length === 0 ? "failed" : failingChecks.length > 0 ? "failed" : "passed",
+                detail: ciEvidence.length === 0
+                    ? "No imported CI evidence exports were supplied."
+                    : failingChecks.length > 0
+                        ? `Imported CI evidence still reports failing checks: ${failingChecks.join(", ")}.`
+                        : `Using ${ciEvidence.length} imported CI evidence export(s) across ${[...new Set(ciEvidence.map((entry) => entry.pipelineName))].length} pipeline(s).`
+            }
+        ];
+        const reviewStatus = ciEvidence.length === 0 || failingChecks.length > 0
+            ? "blocked"
+            : "ready";
+        const normalization = pipelineEvidenceNormalizationSchema.parse({
+            qaReportRefs,
+            securityReportRefs,
+            releaseReportRefs,
+            normalizedEvidenceSources,
+            missingEvidenceSources: [],
+            ciEvidence,
+            ciEvidenceSummary,
+            referencedArtifactKinds,
+            verificationChecks,
+            reviewStatus,
+            provenanceRefs: normalizedEvidenceSources
+        });
+        return agentOutputSchema.parse({
+            summary: `Normalized pipeline evidence across ${normalization.normalizedEvidenceSources.length} source(s) and ${normalization.ciEvidence.length} imported CI evidence export(s).`,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [],
+            requestedTools: [],
+            blockedActionFlags: [],
+            metadata: normalization
+        });
+    }
+};
+const pipelineAnalystAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "pipeline-analyst",
+        displayName: "Pipeline Analyst",
+        category: "release",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "reasoning"
+        },
+        permissions: {
+            model: true,
+            network: false,
+            tools: [],
+            readPaths: ["**/*"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo", "agentResults"],
+        outputs: ["lifecycleArtifacts"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "agentResults"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "release",
+            supportLevel: "internal",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ state, stateSlice }) {
+        const pipelineRequest = getWorkflowInput(stateSlice, "pipelineRequest");
+        const pipelineIssueRefs = getWorkflowInput(stateSlice, "pipelineIssueRefs") ?? [];
+        const pipelineScmRefs = getWorkflowInput(stateSlice, "pipelineScmRefs") ?? [];
+        const pipelineGithubRefs = getWorkflowInput(stateSlice, "pipelineGithubRefs") ?? [];
+        const requestFile = getWorkflowInput(stateSlice, "requestFile");
+        if (!pipelineRequest) {
+            throw new Error("pipeline-evidence-review requires validated pipeline inputs before analysis.");
+        }
+        const evidenceMetadata = pipelineEvidenceNormalizationSchema.safeParse(stateSlice.agentResults?.evidence?.metadata);
+        const normalizedEvidence = evidenceMetadata.success ? evidenceMetadata.data : undefined;
+        const evidenceSources = normalizedEvidence?.normalizedEvidenceSources && normalizedEvidence.normalizedEvidenceSources.length > 0
+            ? normalizedEvidence.normalizedEvidenceSources
+            : pipelineRequest.evidenceSources;
+        const ciEvidenceSummary = normalizedEvidence?.ciEvidenceSummary ?? [];
+        const verificationChecks = normalizedEvidence?.verificationChecks ?? [];
+        const referencedArtifactKinds = normalizedEvidence?.referencedArtifactKinds ?? [];
+        const blockers = [
+            ...verificationChecks
+                .filter((check) => check.status === "failed")
+                .map((check) => check.detail ?? `${check.name} failed during deterministic pipeline review.`)
+        ];
+        const riskSummary = [
+            ...(pipelineRequest.focusAreas.length > 0
+                ? [`Focused review areas still require human interpretation: ${pipelineRequest.focusAreas.join(", ")}.`]
+                : []),
+            ...(referencedArtifactKinds.length > 0
+                ? [`Referenced lifecycle artifacts remain in scope: ${referencedArtifactKinds.join(", ")}.`]
+                : []),
+            ...(ciEvidenceSummary.length > 0
+                ? [`Imported CI provenance spans ${[...new Set(ciEvidenceSummary.map((entry) => entry.provider))].join(", ")}.`]
+                : [])
+        ];
+        const recommendedNextSteps = [
+            ...ciEvidenceSummary.map((entry) => `Review ${entry.displayLabel} (${formatCiEvidenceStatus(entry)}) before moving to deployment or promotion review.`),
+            ...(pipelineRequest.qaReportRefs.length + pipelineRequest.securityReportRefs.length + pipelineRequest.releaseReportRefs.length > 0
+                ? ["Carry the validated QA, security, and release artifacts forward into deployment-gate-review."]
+                : ["Attach downstream QA, security, or release artifacts before using this pipeline report as a deployment gate input."]),
+            ...(pipelineRequest.constraints.length > 0 ? [`Keep follow-up bounded by: ${pipelineRequest.constraints.join("; ")}.`] : [])
+        ];
+        const reviewStatus = blockers.length > 0 ? "blocked" : normalizedEvidence?.reviewStatus ?? "ready";
+        const summary = `Pipeline report prepared for ${pipelineRequest.pipelineScope}.`;
+        const pipelineReport = pipelineArtifactSchema.parse({
+            ...buildLifecycleArtifactEnvelopeBase(state, "Pipeline Evidence Review", summary, [requestFile ?? ".agentops/requests/pipeline.yaml", ...new Set(evidenceSources)], pipelineIssueRefs, pipelineScmRefs, pipelineGithubRefs),
+            artifactKind: "pipeline-report",
+            lifecycleDomain: "release",
+            payload: {
+                pipelineScope: pipelineRequest.pipelineScope,
+                evidenceSources,
+                verificationChecks,
+                ciEvidenceSummary,
+                reviewStatus,
+                blockers,
+                riskSummary,
+                recommendedNextSteps: recommendedNextSteps.length > 0 ? recommendedNextSteps : ["Capture additional bounded CI evidence before follow-on review."],
+                referencedArtifactKinds,
+                provenanceRefs: normalizedEvidence?.provenanceRefs ?? evidenceSources
+            }
+        });
+        return agentOutputSchema.parse({
+            summary,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [pipelineReport],
+            requestedTools: [],
+            blockedActionFlags: [],
+            confidence: 0.76,
+            metadata: {
+                deterministicInputs: {
+                    evidenceSources,
+                    ciEvidenceSummary,
+                    verificationChecks,
+                    referencedArtifactKinds,
+                    focusAreas: pipelineRequest.focusAreas,
+                    constraints: pipelineRequest.constraints
+                },
+                synthesizedAssessment: {
+                    reviewStatus,
+                    blockers,
+                    riskSummary,
+                    recommendedNextSteps: pipelineReport.payload.recommendedNextSteps
+                }
+            }
+        });
+    }
+};
+const deploymentGateIntakeAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "deployment-gate-intake",
+        displayName: "Deployment Gate Intake",
+        category: "release",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "deterministic"
+        },
+        permissions: {
+            model: false,
+            network: false,
+            tools: [],
+            readPaths: [".agentops/requests/**", ".agentops/runs/**"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo"],
+        outputs: ["summary", "metadata"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "context"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "release",
+            supportLevel: "internal",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ stateSlice }) {
+        const deploymentRequest = getWorkflowInput(stateSlice, "deploymentRequest");
+        const deploymentIssueRefs = getWorkflowInput(stateSlice, "deploymentIssueRefs") ?? [];
+        const deploymentScmRefs = getWorkflowInput(stateSlice, "deploymentScmRefs") ?? [];
+        const deploymentGithubRefs = getWorkflowInput(stateSlice, "deploymentGithubRefs") ?? [];
+        const requestFile = getWorkflowInput(stateSlice, "requestFile");
+        if (!deploymentRequest) {
+            throw new Error("deployment-gate-review requires a validated deployment request before runtime execution.");
+        }
+        return agentOutputSchema.parse({
+            summary: `Loaded deployment request from ${requestFile ?? ".agentops/requests/deployment.yaml"} for ${deploymentRequest.targetEnvironment}.`,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [],
+            requestedTools: [],
+            blockedActionFlags: [],
+            metadata: {
+                ...deploymentRequestSchema.parse(deploymentRequest),
+                deploymentIssueRefs,
+                deploymentScmRefs,
+                deploymentGithubRefs,
+                evidenceSourceCount: deploymentRequest.evidenceSources.length +
+                    deploymentRequest.qaReportRefs.length +
+                    deploymentRequest.securityReportRefs.length +
+                    deploymentRequest.releaseReportRefs.length +
+                    deploymentRequest.pipelineReportRefs.length
+            }
+        });
+    }
+};
+const deploymentGateEvidenceNormalizationAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "deployment-gate-evidence-normalizer",
+        displayName: "Deployment Gate Evidence Normalizer",
+        category: "release",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "deterministic"
+        },
+        permissions: {
+            model: false,
+            network: false,
+            tools: [],
+            readPaths: [".agentops/requests/**", ".agentops/runs/**", "**/*.json", "**/*.md"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo", "agentResults"],
+        outputs: ["summary", "metadata"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "agentResults"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "release",
+            supportLevel: "internal",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ stateSlice }) {
+        const deploymentRequest = getWorkflowInput(stateSlice, "deploymentRequest");
+        if (!deploymentRequest) {
+            throw new Error("deployment-gate-review requires validated deployment request inputs before evidence normalization.");
+        }
+        const repoRoot = stateSlice.repo?.root;
+        const intakeMetadata = isRecord(stateSlice.agentResults?.intake?.metadata) ? stateSlice.agentResults.intake.metadata : {};
+        const qaReportRefs = asStringArray(intakeMetadata.qaReportRefs).length > 0
+            ? asStringArray(intakeMetadata.qaReportRefs)
+            : deploymentRequest.qaReportRefs;
+        const securityReportRefs = asStringArray(intakeMetadata.securityReportRefs).length > 0
+            ? asStringArray(intakeMetadata.securityReportRefs)
+            : deploymentRequest.securityReportRefs;
+        const releaseReportRefs = asStringArray(intakeMetadata.releaseReportRefs).length > 0
+            ? asStringArray(intakeMetadata.releaseReportRefs)
+            : deploymentRequest.releaseReportRefs;
+        const pipelineReportRefs = asStringArray(intakeMetadata.pipelineReportRefs).length > 0
+            ? asStringArray(intakeMetadata.pipelineReportRefs)
+            : deploymentRequest.pipelineReportRefs;
+        const evidenceSources = asStringArray(intakeMetadata.evidenceSources).length > 0
+            ? asStringArray(intakeMetadata.evidenceSources)
+            : deploymentRequest.evidenceSources;
+        const normalizedEvidenceSources = [
+            ...new Set([...qaReportRefs, ...securityReportRefs, ...releaseReportRefs, ...pipelineReportRefs, ...evidenceSources])
+        ];
+        const missingEvidenceSources = normalizedEvidenceSources.filter((pathValue) => repoRoot && !existsSync(join(repoRoot, pathValue)));
+        if (missingEvidenceSources.length > 0) {
+            throw new Error(`Deployment evidence source not found: ${missingEvidenceSources[0]}`);
+        }
+        const referencedArtifactKinds = [
+            ...new Set([...qaReportRefs, ...securityReportRefs, ...releaseReportRefs, ...pipelineReportRefs].flatMap((bundleRef) => repoRoot ? loadBundleArtifactKinds(join(repoRoot, bundleRef)) : []))
+        ];
+        const releaseReportReadiness = releaseReportRefs.map((bundleRef) => repoRoot
+            ? evaluateReleaseReportReadiness(join(repoRoot, bundleRef))
+            : { ready: false, detail: `Release report reference cannot be evaluated without a repository root: ${bundleRef}` });
+        const pipelineReportReadiness = pipelineReportRefs.map((bundleRef) => repoRoot
+            ? evaluatePipelineReportReadiness(join(repoRoot, bundleRef))
+            : { ready: false, detail: `Pipeline report reference cannot be evaluated without a repository root: ${bundleRef}` });
+        const ciEvidence = normalizeImportedCiEvidence(repoRoot, normalizedEvidenceSources);
+        const ciEvidenceSummary = ciEvidence.map((entry) => summarizeCiEvidenceForRelease(entry));
+        const failingChecks = ciEvidenceSummary.flatMap((entry) => entry.failingChecks);
+        const verificationChecks = [
+            {
+                name: "qa-report-refs",
+                status: qaReportRefs.length > 0 ? "passed" : "skipped",
+                detail: qaReportRefs.length > 0 ? `Using ${qaReportRefs.length} validated QA report reference(s).` : "No QA report references were supplied."
+            },
+            {
+                name: "security-report-refs",
+                status: securityReportRefs.length > 0 ? "passed" : "skipped",
+                detail: securityReportRefs.length > 0
+                    ? `Using ${securityReportRefs.length} validated security report reference(s).`
+                    : "No security report references were supplied."
+            },
+            {
+                name: "release-report-refs",
+                status: releaseReportRefs.length === 0
+                    ? "skipped"
+                    : releaseReportReadiness.some((entry) => !entry.ready)
+                        ? "failed"
+                        : "passed",
+                detail: releaseReportRefs.length > 0
+                    ? releaseReportReadiness.some((entry) => !entry.ready)
+                        ? releaseReportReadiness.filter((entry) => !entry.ready).map((entry) => entry.detail).join(" ")
+                        : `Using ${releaseReportRefs.length} ready release report reference(s).`
+                    : "No release report references were supplied."
+            },
+            {
+                name: "pipeline-report-refs",
+                status: pipelineReportRefs.length === 0
+                    ? "skipped"
+                    : pipelineReportReadiness.some((entry) => !entry.ready)
+                        ? "failed"
+                        : "passed",
+                detail: pipelineReportRefs.length > 0
+                    ? pipelineReportReadiness.some((entry) => !entry.ready)
+                        ? pipelineReportReadiness.filter((entry) => !entry.ready).map((entry) => entry.detail).join(" ")
+                        : `Using ${pipelineReportRefs.length} ready pipeline report reference(s).`
+                    : "No pipeline report references were supplied."
+            },
+            {
+                name: "imported-ci-evidence",
+                status: ciEvidence.length === 0 ? "failed" : failingChecks.length > 0 ? "failed" : "passed",
+                detail: ciEvidence.length === 0
+                    ? "No imported CI evidence exports were supplied."
+                    : failingChecks.length > 0
+                        ? `Imported CI evidence still reports failing checks: ${failingChecks.join(", ")}.`
+                        : `Using ${ciEvidence.length} imported CI evidence export(s) across ${[...new Set(ciEvidence.map((entry) => entry.pipelineName))].length} pipeline(s).`
+            }
+        ];
+        const gateStatus = ciEvidence.length === 0 || failingChecks.length > 0
+            ? "blocked"
+            : qaReportRefs.length > 0 &&
+                securityReportRefs.length > 0 &&
+                releaseReportRefs.length > 0 &&
+                pipelineReportRefs.length > 0
+                ? "ready_for_approval"
+                : "conditionally_ready";
+        const normalization = deploymentGateEvidenceNormalizationSchema.parse({
+            qaReportRefs,
+            securityReportRefs,
+            releaseReportRefs,
+            pipelineReportRefs,
+            normalizedEvidenceSources,
+            missingEvidenceSources: [],
+            ciEvidence,
+            ciEvidenceSummary,
+            referencedArtifactKinds,
+            verificationChecks,
+            gateStatus,
+            provenanceRefs: normalizedEvidenceSources
+        });
+        return agentOutputSchema.parse({
+            summary: `Normalized deployment-gate evidence across ${normalization.normalizedEvidenceSources.length} source(s) and ${normalization.ciEvidence.length} imported CI evidence export(s).`,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [],
+            requestedTools: [],
+            blockedActionFlags: [],
+            metadata: normalization
+        });
+    }
+};
+const deploymentGateAnalystAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "deployment-gate-analyst",
+        displayName: "Deployment Gate Analyst",
+        category: "release",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "reasoning"
+        },
+        permissions: {
+            model: true,
+            network: false,
+            tools: [],
+            readPaths: ["**/*"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo", "agentResults"],
+        outputs: ["lifecycleArtifacts"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "agentResults"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "release",
+            supportLevel: "internal",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ state, stateSlice }) {
+        const deploymentRequest = getWorkflowInput(stateSlice, "deploymentRequest");
+        const deploymentIssueRefs = getWorkflowInput(stateSlice, "deploymentIssueRefs") ?? [];
+        const deploymentScmRefs = getWorkflowInput(stateSlice, "deploymentScmRefs") ?? [];
+        const deploymentGithubRefs = getWorkflowInput(stateSlice, "deploymentGithubRefs") ?? [];
+        const requestFile = getWorkflowInput(stateSlice, "requestFile");
+        if (!deploymentRequest) {
+            throw new Error("deployment-gate-review requires validated deployment inputs before analysis.");
+        }
+        const evidenceMetadata = deploymentGateEvidenceNormalizationSchema.safeParse(stateSlice.agentResults?.evidence?.metadata);
+        const normalizedEvidence = evidenceMetadata.success ? evidenceMetadata.data : undefined;
+        const evidenceSources = normalizedEvidence?.normalizedEvidenceSources && normalizedEvidence.normalizedEvidenceSources.length > 0
+            ? normalizedEvidence.normalizedEvidenceSources
+            : deploymentRequest.evidenceSources;
+        const ciEvidenceSummary = normalizedEvidence?.ciEvidenceSummary ?? [];
+        const verificationChecks = normalizedEvidence?.verificationChecks ?? [];
+        const referencedArtifactKinds = normalizedEvidence?.referencedArtifactKinds ?? [];
+        const blockers = [
+            ...verificationChecks
+                .filter((check) => check.status === "failed")
+                .map((check) => check.detail ?? `${check.name} failed during deterministic deployment-gate review.`)
+        ];
+        const requiredFollowUpChecks = [
+            ...verificationChecks
+                .filter((check) => check.status === "skipped")
+                .map((check) => check.detail ?? `${check.name} still needs explicit follow-up.`),
+            ...ciEvidenceSummary.map((entry) => `Confirm ${entry.displayLabel} remains current for the ${deploymentRequest.targetEnvironment} candidate.`),
+            ...(blockers.length === 0 ? ["Obtain explicit maintainer approval before any deploy, publish, or promotion action."] : [])
+        ];
+        const gateStatus = blockers.length > 0 ? "blocked" : normalizedEvidence?.gateStatus ?? "conditionally_ready";
+        const summary = `Deployment gate report prepared for ${deploymentRequest.targetEnvironment}.`;
+        const deploymentGateReport = deploymentGateArtifactSchema.parse({
+            ...buildLifecycleArtifactEnvelopeBase(state, "Deployment Gate Review", summary, [requestFile ?? ".agentops/requests/deployment.yaml", ...new Set(evidenceSources)], deploymentIssueRefs, deploymentScmRefs, deploymentGithubRefs),
+            artifactKind: "deployment-gate-report",
+            lifecycleDomain: "release",
+            payload: {
+                deploymentScope: deploymentRequest.deploymentScope,
+                targetEnvironment: deploymentRequest.targetEnvironment,
+                evidenceSources,
+                verificationChecks,
+                ciEvidenceSummary,
+                gateStatus,
+                blockers,
+                requiredFollowUpChecks,
+                referencedArtifactKinds,
+                provenanceRefs: normalizedEvidence?.provenanceRefs ?? evidenceSources
+            }
+        });
+        return agentOutputSchema.parse({
+            summary,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [deploymentGateReport],
+            requestedTools: [],
+            blockedActionFlags: [],
+            confidence: 0.77,
+            metadata: {
+                deterministicInputs: {
+                    targetEnvironment: deploymentRequest.targetEnvironment,
+                    evidenceSources,
+                    ciEvidenceSummary,
+                    verificationChecks,
+                    referencedArtifactKinds,
+                    constraints: deploymentRequest.constraints
+                },
+                synthesizedAssessment: {
+                    gateStatus,
+                    blockers,
+                    requiredFollowUpChecks: deploymentGateReport.payload.requiredFollowUpChecks
+                }
+            }
+        });
+    }
+};
+const promotionApprovalIntakeAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "promotion-approval-intake",
+        displayName: "Promotion Approval Intake",
+        category: "release",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "deterministic"
+        },
+        permissions: {
+            model: false,
+            network: false,
+            tools: [],
+            readPaths: [".agentops/requests/**", ".agentops/runs/**"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo"],
+        outputs: ["summary", "metadata"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "context"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "release",
+            supportLevel: "internal",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ stateSlice }) {
+        const promotionRequest = getWorkflowInput(stateSlice, "promotionRequest");
+        const promotionIssueRefs = getWorkflowInput(stateSlice, "promotionIssueRefs") ?? [];
+        const promotionScmRefs = getWorkflowInput(stateSlice, "promotionScmRefs") ?? [];
+        const promotionGithubRefs = getWorkflowInput(stateSlice, "promotionGithubRefs") ?? [];
+        const requestFile = getWorkflowInput(stateSlice, "requestFile");
+        if (!promotionRequest) {
+            throw new Error("promotion-approval requires a validated promotion request before runtime execution.");
+        }
+        return agentOutputSchema.parse({
+            summary: `Loaded promotion approval request from ${requestFile ?? ".agentops/requests/promotion.yaml"} for ${promotionRequest.targetEnvironment}.`,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [],
+            requestedTools: [],
+            blockedActionFlags: [],
+            metadata: {
+                ...promotionRequestSchema.parse(promotionRequest),
+                promotionIssueRefs,
+                promotionScmRefs,
+                promotionGithubRefs,
+                evidenceSourceCount: promotionRequest.evidenceSources.length +
+                    promotionRequest.qaReportRefs.length +
+                    promotionRequest.securityReportRefs.length +
+                    promotionRequest.releaseReportRefs.length +
+                    promotionRequest.deploymentGateReportRefs.length
+            }
+        });
+    }
+};
+const promotionApprovalEvidenceNormalizationAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "promotion-approval-evidence-normalizer",
+        displayName: "Promotion Approval Evidence Normalizer",
+        category: "release",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "deterministic"
+        },
+        permissions: {
+            model: false,
+            network: false,
+            tools: [],
+            readPaths: [".agentops/requests/**", ".agentops/runs/**", "**/*.json", "**/*.md"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo", "agentResults"],
+        outputs: ["summary", "metadata"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "agentResults"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "release",
+            supportLevel: "internal",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ stateSlice }) {
+        const promotionRequest = getWorkflowInput(stateSlice, "promotionRequest");
+        if (!promotionRequest) {
+            throw new Error("promotion-approval requires validated promotion request inputs before evidence normalization.");
+        }
+        const repoRoot = stateSlice.repo?.root;
+        const intakeMetadata = isRecord(stateSlice.agentResults?.intake?.metadata) ? stateSlice.agentResults.intake.metadata : {};
+        const qaReportRefs = asStringArray(intakeMetadata.qaReportRefs).length > 0
+            ? asStringArray(intakeMetadata.qaReportRefs)
+            : promotionRequest.qaReportRefs;
+        const securityReportRefs = asStringArray(intakeMetadata.securityReportRefs).length > 0
+            ? asStringArray(intakeMetadata.securityReportRefs)
+            : promotionRequest.securityReportRefs;
+        const releaseReportRefs = asStringArray(intakeMetadata.releaseReportRefs).length > 0
+            ? asStringArray(intakeMetadata.releaseReportRefs)
+            : promotionRequest.releaseReportRefs;
+        const deploymentGateReportRefs = asStringArray(intakeMetadata.deploymentGateReportRefs).length > 0
+            ? asStringArray(intakeMetadata.deploymentGateReportRefs)
+            : promotionRequest.deploymentGateReportRefs;
+        const evidenceSources = asStringArray(intakeMetadata.evidenceSources).length > 0
+            ? asStringArray(intakeMetadata.evidenceSources)
+            : promotionRequest.evidenceSources;
+        const normalizedEvidenceSources = [
+            ...new Set([...qaReportRefs, ...securityReportRefs, ...releaseReportRefs, ...deploymentGateReportRefs, ...evidenceSources])
+        ];
+        const missingEvidenceSources = normalizedEvidenceSources.filter((pathValue) => repoRoot && !existsSync(join(repoRoot, pathValue)));
+        if (missingEvidenceSources.length > 0) {
+            throw new Error(`Promotion evidence source not found: ${missingEvidenceSources[0]}`);
+        }
+        const referencedArtifactKinds = [
+            ...new Set([...qaReportRefs, ...securityReportRefs, ...releaseReportRefs, ...deploymentGateReportRefs].flatMap((bundleRef) => repoRoot ? loadBundleArtifactKinds(join(repoRoot, bundleRef)) : []))
+        ];
+        const releaseReportReadiness = releaseReportRefs.map((bundleRef) => repoRoot
+            ? evaluateReleaseReportReadiness(join(repoRoot, bundleRef))
+            : { ready: false, detail: `Release report reference cannot be evaluated without a repository root: ${bundleRef}` });
+        const deploymentGateReadiness = deploymentGateReportRefs.map((bundleRef) => repoRoot
+            ? evaluateDeploymentGateApprovalReadiness(join(repoRoot, bundleRef), promotionRequest.targetEnvironment)
+            : { ready: false, detail: `Deployment gate reference cannot be evaluated without a repository root: ${bundleRef}` });
+        const ciEvidence = normalizeImportedCiEvidence(repoRoot, normalizedEvidenceSources);
+        const ciEvidenceSummary = ciEvidence.map((entry) => summarizeCiEvidenceForRelease(entry));
+        const failingChecks = ciEvidenceSummary.flatMap((entry) => entry.failingChecks);
+        const verificationChecks = [
+            {
+                name: "qa-report-refs",
+                status: qaReportRefs.length > 0 ? "passed" : "skipped",
+                detail: qaReportRefs.length > 0 ? `Using ${qaReportRefs.length} validated QA report reference(s).` : "No QA report references were supplied."
+            },
+            {
+                name: "security-report-refs",
+                status: securityReportRefs.length > 0 ? "passed" : "skipped",
+                detail: securityReportRefs.length > 0
+                    ? `Using ${securityReportRefs.length} validated security report reference(s).`
+                    : "No security report references were supplied."
+            },
+            {
+                name: "release-report-refs",
+                status: releaseReportRefs.length === 0
+                    ? "failed"
+                    : releaseReportReadiness.some((entry) => !entry.ready)
+                        ? "failed"
+                        : "passed",
+                detail: releaseReportRefs.length > 0
+                    ? releaseReportReadiness.some((entry) => !entry.ready)
+                        ? releaseReportReadiness.filter((entry) => !entry.ready).map((entry) => entry.detail).join(" ")
+                        : `Using ${releaseReportRefs.length} ready release report reference(s).`
+                    : "At least one ready release report reference is required."
+            },
+            {
+                name: "deployment-gate-report-refs",
+                status: deploymentGateReportRefs.length === 0
+                    ? "failed"
+                    : deploymentGateReadiness.some((entry) => !entry.ready)
+                        ? "failed"
+                        : "passed",
+                detail: deploymentGateReportRefs.length > 0
+                    ? deploymentGateReadiness.some((entry) => !entry.ready)
+                        ? deploymentGateReadiness.filter((entry) => !entry.ready).map((entry) => entry.detail).join(" ")
+                        : `Using ${deploymentGateReportRefs.length} ready deployment gate report reference(s) for ${promotionRequest.targetEnvironment}.`
+                    : "At least one ready deployment gate report reference is required."
+            },
+            {
+                name: "imported-ci-evidence",
+                status: ciEvidence.length === 0 ? "failed" : failingChecks.length > 0 ? "failed" : "passed",
+                detail: ciEvidence.length === 0
+                    ? "No imported CI evidence exports were supplied."
+                    : failingChecks.length > 0
+                        ? `Imported CI evidence still reports failing checks: ${failingChecks.join(", ")}.`
+                        : `Using ${ciEvidence.length} imported CI evidence export(s) across ${[...new Set(ciEvidence.map((entry) => entry.pipelineName))].length} pipeline(s).`
+            }
+        ];
+        const approvalStatus = verificationChecks.some((check) => check.status === "failed")
+            ? "blocked"
+            : qaReportRefs.length > 0 && securityReportRefs.length > 0
+                ? "approval_recommended"
+                : "needs_follow_up";
+        const approvalRecommendations = [
+            {
+                action: "promote-release",
+                classification: approvalStatus === "approval_recommended" ? "approval_required" : "deny",
+                reason: approvalStatus === "approval_recommended"
+                    ? "Promotion remains a release-significant side effect and requires explicit maintainer approval."
+                    : "Keep release promotion blocked until bounded release and deployment gate evidence is complete."
+            },
+            {
+                action: "publish-packages",
+                classification: approvalStatus === "approval_recommended" ? "approval_required" : "deny",
+                reason: approvalStatus === "approval_recommended"
+                    ? "Package publication remains outside the default read-only workflow path."
+                    : "Do not publish packages while promotion approval remains blocked or incomplete."
+            }
+        ];
+        const normalization = promotionApprovalEvidenceNormalizationSchema.parse({
+            qaReportRefs,
+            securityReportRefs,
+            releaseReportRefs,
+            deploymentGateReportRefs,
+            normalizedEvidenceSources,
+            missingEvidenceSources: [],
+            ciEvidence,
+            ciEvidenceSummary,
+            referencedArtifactKinds,
+            verificationChecks,
+            approvalRecommendations,
+            approvalStatus,
+            provenanceRefs: normalizedEvidenceSources
+        });
+        return agentOutputSchema.parse({
+            summary: `Normalized promotion approval evidence across ${normalization.normalizedEvidenceSources.length} source(s) and ${normalization.ciEvidence.length} imported CI evidence export(s).`,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [],
+            requestedTools: [],
+            blockedActionFlags: [],
+            metadata: normalization
+        });
+    }
+};
+const promotionApprovalAnalystAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "promotion-approval-analyst",
+        displayName: "Promotion Approval Analyst",
+        category: "release",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "reasoning"
+        },
+        permissions: {
+            model: true,
+            network: false,
+            tools: [],
+            readPaths: ["**/*"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo", "agentResults"],
+        outputs: ["lifecycleArtifacts"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "agentResults"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "release",
+            supportLevel: "internal",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ state, stateSlice }) {
+        const promotionRequest = getWorkflowInput(stateSlice, "promotionRequest");
+        const promotionIssueRefs = getWorkflowInput(stateSlice, "promotionIssueRefs") ?? [];
+        const promotionScmRefs = getWorkflowInput(stateSlice, "promotionScmRefs") ?? [];
+        const promotionGithubRefs = getWorkflowInput(stateSlice, "promotionGithubRefs") ?? [];
+        const requestFile = getWorkflowInput(stateSlice, "requestFile");
+        if (!promotionRequest) {
+            throw new Error("promotion-approval requires validated promotion inputs before analysis.");
+        }
+        const evidenceMetadata = promotionApprovalEvidenceNormalizationSchema.safeParse(stateSlice.agentResults?.evidence?.metadata);
+        const normalizedEvidence = evidenceMetadata.success ? evidenceMetadata.data : undefined;
+        const evidenceSources = normalizedEvidence?.normalizedEvidenceSources && normalizedEvidence.normalizedEvidenceSources.length > 0
+            ? normalizedEvidence.normalizedEvidenceSources
+            : promotionRequest.evidenceSources;
+        const ciEvidenceSummary = normalizedEvidence?.ciEvidenceSummary ?? [];
+        const verificationChecks = normalizedEvidence?.verificationChecks ?? [];
+        const referencedArtifactKinds = normalizedEvidence?.referencedArtifactKinds ?? [];
+        const blockers = [
+            ...verificationChecks
+                .filter((check) => check.status === "failed")
+                .map((check) => check.detail ?? `${check.name} failed during deterministic promotion approval review.`)
+        ];
+        const approvalStatus = blockers.length > 0 ? "blocked" : normalizedEvidence?.approvalStatus ?? "needs_follow_up";
+        const requiredApprovals = [
+            "Obtain explicit maintainer approval before any promotion or publish action.",
+            `Confirm the ${promotionRequest.targetEnvironment} deployment owner accepts the current promotion window.`
+        ];
+        const recommendedNextSteps = [
+            ...ciEvidenceSummary.map((entry) => `Review ${entry.displayLabel} (${formatCiEvidenceStatus(entry)}) before approving promotion.`),
+            ...(promotionRequest.qaReportRefs.length > 0 || promotionRequest.securityReportRefs.length > 0
+                ? ["Carry the validated QA and security artifacts into the promotion approval packet."]
+                : ["Attach QA and security artifacts if additional assurance is required before promotion."]),
+            "Keep deployment, publication, and tag creation outside this review-only workflow.",
+            ...(promotionRequest.constraints.length > 0 ? [`Keep follow-up bounded by: ${promotionRequest.constraints.join("; ")}.`] : [])
+        ];
+        const approvalRecommendations = normalizedEvidence?.approvalRecommendations ?? [
+            {
+                action: "promote-release",
+                classification: approvalStatus === "approval_recommended" ? "approval_required" : "deny",
+                reason: approvalStatus === "approval_recommended"
+                    ? "Promotion remains a release-significant side effect and requires explicit maintainer approval."
+                    : "Keep release promotion blocked until bounded release and deployment gate evidence is complete."
+            }
+        ];
+        const summary = `Promotion approval report prepared for ${promotionRequest.targetEnvironment}.`;
+        const promotionApprovalReport = promotionApprovalArtifactSchema.parse({
+            ...buildLifecycleArtifactEnvelopeBase(state, "Promotion Approval Review", summary, [requestFile ?? ".agentops/requests/promotion.yaml", ...new Set(evidenceSources)], promotionIssueRefs, promotionScmRefs, promotionGithubRefs),
+            artifactKind: "promotion-approval-report",
+            lifecycleDomain: "release",
+            payload: {
+                promotionScope: promotionRequest.promotionScope,
+                targetEnvironment: promotionRequest.targetEnvironment,
+                evidenceSources,
+                verificationChecks,
+                ciEvidenceSummary,
+                approvalStatus,
+                blockers,
+                requiredApprovals,
+                recommendedNextSteps,
+                approvalRecommendations: approvalRecommendations.map((recommendation) => releaseApprovalRecommendationSchema.parse(recommendation)),
+                referencedArtifactKinds,
+                provenanceRefs: normalizedEvidence?.provenanceRefs ?? evidenceSources
+            }
+        });
+        return agentOutputSchema.parse({
+            summary,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [promotionApprovalReport],
+            requestedTools: [],
+            blockedActionFlags: [],
+            confidence: 0.78,
+            metadata: {
+                deterministicInputs: {
+                    targetEnvironment: promotionRequest.targetEnvironment,
+                    evidenceSources,
+                    ciEvidenceSummary,
+                    verificationChecks,
+                    referencedArtifactKinds,
+                    constraints: promotionRequest.constraints
+                },
+                synthesizedAssessment: {
+                    approvalStatus,
+                    blockers,
+                    requiredApprovals,
+                    recommendedNextSteps
+                }
+            }
+        });
+    }
+};
+const securityEvidenceNormalizationAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "security-evidence-normalizer",
+        displayName: "Security Evidence Normalizer",
+        category: "security",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "deterministic"
+        },
+        permissions: {
+            model: false,
+            network: false,
+            tools: [],
+            readPaths: [".agentops/requests/**", ".agentops/runs/**", "**/*.json", "**/*.md", "**/package.json"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo", "agentResults"],
+        outputs: ["summary", "metadata"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "agentResults"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "security",
+            supportLevel: "internal",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ stateSlice }) {
+        const securityRequest = getWorkflowInput(stateSlice, "securityRequest");
+        if (!securityRequest) {
+            throw new Error("security-review requires validated security request inputs before evidence normalization.");
+        }
+        const repoRoot = stateSlice.repo?.root;
+        const intakeMetadata = isRecord(stateSlice.agentResults?.intake?.metadata) ? stateSlice.agentResults.intake.metadata : {};
+        const targetType = typeof intakeMetadata.targetType === "string" && intakeMetadata.targetType === "artifact-bundle"
+            ? "artifact-bundle"
+            : "local-reference";
+        const targetPath = repoRoot ? join(repoRoot, securityRequest.targetRef) : securityRequest.targetRef;
+        if (repoRoot && !existsSync(targetPath)) {
+            throw new Error(`Security target reference not found: ${securityRequest.targetRef}`);
+        }
+        const referencedArtifactKinds = targetType === "artifact-bundle" ? loadBundleArtifactKinds(targetPath) : [];
+        const normalizedEvidenceSources = [...new Set([securityRequest.targetRef, ...securityRequest.evidenceSources])];
+        const missingEvidenceSources = normalizedEvidenceSources.filter((pathValue) => repoRoot && !existsSync(join(repoRoot, pathValue)));
+        if (missingEvidenceSources.length > 0) {
+            throw new Error(`Security evidence source not found: ${missingEvidenceSources[0]}`);
+        }
+        const normalizedFocusAreas = securityRequest.focusAreas.length > 0 ? [...new Set(securityRequest.focusAreas)] : ["general-review"];
+        const affectedPackages = targetType === "artifact-bundle"
+            ? [...new Set(loadBundleArtifactPayloadPaths(targetPath).map(derivePackageScope).filter((value) => Boolean(value)))]
+            : [];
+        const dependencyIntegrityEvidence = collectDependencyIntegrityEvidence(repoRoot, stateSlice.repo?.packageManager || "unknown", resolveDependencyManifestPaths(repoRoot, ["package.json", ...affectedPackages]));
+        const dependencyIntegritySignals = buildDependencyIntegritySignals(dependencyIntegrityEvidence);
+        const securitySignals = [
+            ...(referencedArtifactKinds.length > 0 ? [`Referenced artifact kinds: ${referencedArtifactKinds.join(", ")}`] : []),
+            ...(affectedPackages.length > 0 ? [`Affected packages inferred from bounded artifact payloads: ${affectedPackages.join(", ")}`] : []),
+            ...(normalizedFocusAreas.length > 0 ? [`Requested focus areas: ${normalizedFocusAreas.join(", ")}`] : []),
+            ...dependencyIntegritySignals,
+            "Security evidence collection remains local, read-only, and bounded to validated references."
+        ];
+        const provenanceRefs = [
+            securityRequest.targetRef,
+            ...securityRequest.evidenceSources,
+            ...dependencyIntegrityEvidence.flatMap((entry) => entry.provenanceRefs),
+            ...referencedArtifactKinds.map((artifactKind) => `${securityRequest.targetRef}#${artifactKind}`)
+        ];
+        const normalization = securityEvidenceNormalizationSchema.parse({
+            targetRef: securityRequest.targetRef,
             targetType,
             referencedArtifactKinds,
             normalizedEvidenceSources,
             missingEvidenceSources: [],
             normalizedFocusAreas,
             securitySignals,
+            dependencyIntegrityEvidence,
             provenanceRefs: [...new Set(provenanceRefs)],
             affectedPackages
         });
@@ -2037,6 +3726,7 @@ const securityAnalystAgent = {
     async execute({ state, stateSlice }) {
         const securityRequest = getWorkflowInput(stateSlice, "securityRequest");
         const securityIssueRefs = getWorkflowInput(stateSlice, "securityIssueRefs") ?? [];
+        const securityScmRefs = getWorkflowInput(stateSlice, "securityScmRefs") ?? [];
         const securityGithubRefs = getWorkflowInput(stateSlice, "securityGithubRefs") ?? [];
         const requestFile = getWorkflowInput(stateSlice, "requestFile");
         if (!securityRequest) {
@@ -2048,6 +3738,8 @@ const securityAnalystAgent = {
         const referencedArtifactKinds = normalizedEvidence?.referencedArtifactKinds ?? asStringArray(intakeMetadata.referencedArtifactKinds);
         const normalizedFocusAreas = normalizedEvidence?.normalizedFocusAreas ?? asStringArray(intakeMetadata.focusAreas);
         const normalizedConstraints = asStringArray(intakeMetadata.constraints);
+        const dependencyIntegrityEvidence = normalizedEvidence?.dependencyIntegrityEvidence ?? [];
+        const dependencyIntegritySignals = buildDependencyIntegritySignals(dependencyIntegrityEvidence);
         const evidenceSources = normalizedEvidence?.normalizedEvidenceSources && normalizedEvidence.normalizedEvidenceSources.length > 0
             ? normalizedEvidence.normalizedEvidenceSources
             : asStringArray(intakeMetadata.evidenceSources).length > 0
@@ -2084,6 +3776,7 @@ const securityAnalystAgent = {
         ];
         const followUpWork = [
             ...(normalizedEvidence?.securitySignals ?? []),
+            ...dependencyIntegritySignals,
             ...(referencedArtifactKinds.length > 0
                 ? [`Confirm the security posture for referenced artifacts: ${referencedArtifactKinds.join(", ")}.`]
                 : []),
@@ -2094,7 +3787,7 @@ const securityAnalystAgent = {
             ...buildLifecycleArtifactEnvelopeBase(state, "Security Review", summary, [
                 requestFile ?? ".agentops/requests/security.yaml",
                 ...(normalizedEvidence?.provenanceRefs ?? [securityRequest.targetRef, ...securityRequest.evidenceSources])
-            ], securityIssueRefs, securityGithubRefs),
+            ], securityIssueRefs, securityScmRefs, securityGithubRefs),
             artifactKind: "security-report",
             lifecycleDomain: "security",
             redaction: {
@@ -2115,7 +3808,8 @@ const securityAnalystAgent = {
                     : securityRequest.releaseContext === "candidate"
                         ? "candidate release requires explicit security review before promotion."
                         : "no release context was supplied; security output remains advisory.",
-                followUpWork
+                followUpWork,
+                dependencyIntegritySignals
             }
         });
         return agentOutputSchema.parse({
@@ -2133,6 +3827,7 @@ const securityAnalystAgent = {
                     focusAreas,
                     constraints: normalizedConstraints,
                     referencedArtifactKinds,
+                    dependencyIntegrityEvidence,
                     normalizedEvidence: normalizedEvidence ?? null
                 },
                 synthesizedAssessment: {
@@ -2217,6 +3912,7 @@ const qaEvidenceNormalizationAgent = {
         const allowlistedCommands = new Set(allowedValidationCommands.map((entry) => entry.command));
         const normalizedExecutedChecks = qaRequest.executedChecks.map(normalizeRequestedCommand);
         const unrecognizedExecutedChecks = normalizedExecutedChecks.filter((command) => !allowlistedCommands.has(command));
+        const ciEvidence = normalizeImportedCiEvidence(repoRoot, normalizedEvidenceSources);
         const githubActions = normalizeGitHubActionsEvidence(repoRoot, normalizedEvidenceSources);
         const normalization = qaEvidenceNormalizationSchema.parse({
             targetRef: qaRequest.targetRef,
@@ -2228,10 +3924,11 @@ const qaEvidenceNormalizationAgent = {
             unrecognizedExecutedChecks,
             affectedPackages,
             allowedValidationCommands,
+            ciEvidence,
             githubActions
         });
         return agentOutputSchema.parse({
-            summary: `Normalized QA evidence across ${normalization.normalizedEvidenceSources.length} source(s), ${normalization.allowedValidationCommands.length} allowlisted validation command(s), and ${normalization.githubActions.evidence.length} GitHub Actions evidence export(s).`,
+            summary: `Normalized QA evidence across ${normalization.normalizedEvidenceSources.length} source(s), ${normalization.allowedValidationCommands.length} allowlisted validation command(s), ${normalization.githubActions.evidence.length} GitHub Actions export(s), and ${normalization.ciEvidence.length} generic CI evidence export(s).`,
             findings: [],
             proposedActions: [],
             lifecycleArtifacts: [],
@@ -2280,6 +3977,7 @@ const qaAnalystAgent = {
     async execute({ state, stateSlice }) {
         const qaRequest = getWorkflowInput(stateSlice, "qaRequest");
         const qaIssueRefs = getWorkflowInput(stateSlice, "qaIssueRefs") ?? [];
+        const qaScmRefs = getWorkflowInput(stateSlice, "qaScmRefs") ?? [];
         const qaGithubRefs = getWorkflowInput(stateSlice, "qaGithubRefs") ?? [];
         const requestFile = getWorkflowInput(stateSlice, "requestFile");
         if (!qaRequest) {
@@ -2302,6 +4000,10 @@ const qaAnalystAgent = {
                 failingChecks: [],
                 provenanceRefs: []
             };
+        const normalizedCiEvidence = normalizedEvidence?.ciEvidence ?? [];
+        const normalizedCiEvidenceSummary = normalizedCiEvidence.map((entry) => summarizeCiEvidenceForRelease(entry));
+        const normalizedCiWorkflowNames = [...new Set(normalizedCiEvidence.map((entry) => entry.pipelineName))];
+        const normalizedCiFailingChecks = [...new Set(normalizedCiEvidence.flatMap((entry) => summarizeCiEvidenceFailures(entry)))];
         const targetType = normalizedEvidence?.targetType
             ? normalizedEvidence.targetType
             : typeof intakeMetadata.targetType === "string"
@@ -2341,12 +4043,14 @@ const qaAnalystAgent = {
             ...(focusAreas.includes("coverage") ? ["Coverage evidence still needs deterministic normalization before it can be promoted to an official QA signal."] : []),
             ...(executedChecks.length === 0 ? ["No executed validation checks were recorded in the request."] : []),
             ...unrecognizedExecutedChecks.map((command) => `Executed check is outside the bounded allowlist and still needs manual interpretation: ${command}`),
-            ...normalizedGithubActions.failingChecks.map((checkName) => `GitHub Actions evidence still reports a failing check that needs manual review: ${checkName}`)
+            ...normalizedGithubActions.failingChecks.map((checkName) => `GitHub Actions evidence still reports a failing check that needs manual review: ${checkName}`),
+            ...normalizedCiFailingChecks.map((checkName) => `Imported CI evidence still reports a failing check that needs manual review: ${checkName}`)
         ];
         const recommendedNextChecks = [
             ...executedChecks.map((command) => `Review the recorded output for \`${command}\` before promotion.`),
             ...focusAreas.map((focusArea) => `Confirm whether ${focusArea} needs additional deterministic QA evidence.`),
             ...normalizedGithubActions.workflowNames.map((workflowName) => `Review the exported GitHub Actions evidence for workflow \`${workflowName}\` before promotion.`),
+            ...normalizedCiWorkflowNames.map((workflowName) => `Review the imported CI evidence for pipeline \`${workflowName}\` before promotion.`),
             ...(normalizedConstraints.length > 0 ? [`Keep QA follow-up bounded by: ${normalizedConstraints.join("; ")}.`] : [])
         ];
         const summary = `QA report prepared for ${qaRequest.targetRef}.`;
@@ -2356,7 +4060,7 @@ const qaAnalystAgent = {
                 ? "candidate release still requires explicit QA review before promotion."
                 : "no release context was supplied; QA output remains advisory.";
         const qaReport = qaArtifactSchema.parse({
-            ...buildArtifactEnvelopeBase(state, summary, [requestFile ?? ".agentops/requests/qa.yaml", qaRequest.targetRef, ...qaRequest.evidenceSources], qaIssueRefs, qaGithubRefs),
+            ...buildArtifactEnvelopeBase(state, summary, [requestFile ?? ".agentops/requests/qa.yaml", qaRequest.targetRef, ...qaRequest.evidenceSources], qaIssueRefs, qaScmRefs, qaGithubRefs),
             artifactKind: "qa-report",
             lifecycleDomain: "test",
             workflow: {
@@ -2367,13 +4071,21 @@ const qaAnalystAgent = {
                 targetRef: qaRequest.targetRef,
                 evidenceSources,
                 executedChecks,
+                ciEvidenceSummary: normalizedCiEvidenceSummary,
                 findings,
                 coverageGaps,
                 recommendedNextChecks: recommendedNextChecks.length > 0
                     ? recommendedNextChecks
                     : ["Capture additional bounded QA evidence before promotion."],
-                releaseImpact: normalizedGithubActions.failingChecks.length > 0
-                    ? `${releaseImpactBase} GitHub Actions evidence still shows failing checks: ${normalizedGithubActions.failingChecks.join(", ")}.`
+                releaseImpact: normalizedGithubActions.failingChecks.length > 0 || normalizedCiFailingChecks.length > 0
+                    ? `${releaseImpactBase} ${[
+                        normalizedGithubActions.failingChecks.length > 0
+                            ? `GitHub Actions evidence still shows failing checks: ${normalizedGithubActions.failingChecks.join(", ")}.`
+                            : undefined,
+                        normalizedCiFailingChecks.length > 0
+                            ? `Imported CI evidence still shows failing checks: ${normalizedCiFailingChecks.join(", ")}.`
+                            : undefined
+                    ].filter((value) => Boolean(value)).join(" ")}`
                     : releaseImpactBase
             }
         });
@@ -2393,6 +4105,7 @@ const qaAnalystAgent = {
                     executedChecks,
                     focusAreas,
                     constraints: normalizedConstraints,
+                    ciEvidence: normalizedCiEvidence,
                     githubActions: normalizedGithubActions
                 },
                 synthesizedAssessment: {
@@ -2602,7 +4315,7 @@ const implementationPlannerAgent = {
         ];
         const summary = `Implementation proposal prepared for ${implementationRequest.implementationGoal}.`;
         const implementationProposal = implementationArtifactSchema.parse({
-            ...buildArtifactEnvelopeBase(state, summary, [requestFile ?? ".agentops/requests/implementation.yaml", implementationRequest.designRecordRef], designRecord.source.issueRefs, designRecord.source.githubRefs),
+            ...buildArtifactEnvelopeBase(state, summary, [requestFile ?? ".agentops/requests/implementation.yaml", implementationRequest.designRecordRef], designRecord.source.issueRefs, designRecord.source.scmRefs, designRecord.source.githubRefs),
             artifactKind: "implementation-proposal",
             lifecycleDomain: "build",
             workflow: {
@@ -2715,7 +4428,7 @@ const designAnalystAgent = {
         ];
         const summary = `Design record prepared for ${designRequest.decisionTarget}.`;
         const designRecord = designArtifactSchema.parse({
-            ...buildArtifactEnvelopeBase(state, summary, [requestFile ?? ".agentops/requests/design.yaml", designRequest.planningBriefRef], planningBrief.source.issueRefs, planningBrief.source.githubRefs),
+            ...buildArtifactEnvelopeBase(state, summary, [requestFile ?? ".agentops/requests/design.yaml", designRequest.planningBriefRef], planningBrief.source.issueRefs, planningBrief.source.scmRefs, planningBrief.source.githubRefs),
             artifactKind: "design-record",
             lifecycleDomain: "design",
             workflow: {
@@ -3013,6 +4726,15 @@ export function createBuiltinAgentRegistry() {
         ["release-intake", releaseIntakeAgent],
         ["release-evidence-normalizer", releaseEvidenceNormalizationAgent],
         ["release-analyst", releaseAnalystAgent],
+        ["pipeline-intake", pipelineIntakeAgent],
+        ["pipeline-evidence-normalizer", pipelineEvidenceNormalizationAgent],
+        ["pipeline-analyst", pipelineAnalystAgent],
+        ["deployment-gate-intake", deploymentGateIntakeAgent],
+        ["deployment-gate-evidence-normalizer", deploymentGateEvidenceNormalizationAgent],
+        ["deployment-gate-analyst", deploymentGateAnalystAgent],
+        ["promotion-approval-intake", promotionApprovalIntakeAgent],
+        ["promotion-approval-evidence-normalizer", promotionApprovalEvidenceNormalizationAgent],
+        ["promotion-approval-analyst", promotionApprovalAnalystAgent],
         ["security-evidence-normalizer", securityEvidenceNormalizationAgent],
         ["security-analyst", securityAnalystAgent],
         ["qa-evidence-normalizer", qaEvidenceNormalizationAgent],